Tutorial: Senden von Pushbenachrichtigungen an bestimmte iOS-Geräte mit Azure Notification Hubs

Artikel
04/20/2023

Übersicht

In diesem Tutorial wird gezeigt, wie Sie mit Azure Notification Hubs Benachrichtigungen zu aktuellen Nachrichten an eine iOS-Apps senden. Anschließend können Sie sich für Kategorien aktueller Nachrichten registrieren, die Sie interessieren, und nur Pushbenachrichtigungen für diese Kategorien empfangen. Dieses Szenario ist ein häufiges Muster für viele Apps, bei denen Benachrichtigungen an Benutzergruppen gesendet werden müssen, die zuvor Interesse daran bekundet haben, zum Beispiel RSS-Feeds, Apps für Musikfans usw.

Übertragungsszenarien werden durch das Einfügen von einem oder mehreren Tags möglich, wenn eine Registrierung im Notification Hub erstellt wird. Wenn Benachrichtigungen an ein Tag gesendet werden, erhalten Geräte, die für das Tag registriert wurden, diese Benachrichtigung. Da es sich bei Tags um Zeichenfolgen handelt, müssen diese nicht im Voraus bereitgestellt werden. Weitere Informationen zu Tags finden Sie unter Notification Hubs – Weiterleitung und Tagausdrücke.

In diesem Tutorial führen Sie die folgenden Schritte aus:

Hinzufügen einer Kategorieauswahl zur App
Senden von Benachrichtigungen mit Tags
Senden von Benachrichtigungen vom Gerät
Ausführen der App und Erzeugen von Benachrichtigungen

Voraussetzungen

Dieses Thema basiert auf der App, die Sie unter Tutorial: Senden von Pushbenachrichtigungen an iOS-Apps mit Azure Notification Hubs erstellt haben. Bevor Sie dieses Tutorial starten, müssen Sie bereits Tutorial: Senden von Pushbenachrichtigungen an iOS-Apps mit Azure Notification Hubs abgeschlossen haben.

Hinzufügen der Kategorieauswahl zur App

Zunächst werden Sie Benutzeroberflächenelemente zum vorhandenen Storyboard hinzufügen, mit denen Benutzer Kategorien für die Registrierung auswählen können. Die durch den Benutzer ausgewählten Kategorien werden auf dem Gerät gespeichert. Wenn die App gestartet wird, wird eine Geräteregistrierung in Ihrem Notification Hub mit den ausgewählten Kategorien als Tags erstellt.

Fügen Sie die folgenden Komponenten aus der Objektbibliothek zu MainStoryboard_iPhone.storyboard hinzu:
- Eine Beschriftung mit dem Text "Breaking News",
- Beschriftungen mit den Kategorien "World", "Politics", "Business", "Technology", "Science", "Sports",
- Sechs Switches, einen pro Kategorie, wobei für jeden Switch State standardmäßig auf Off festgelegt ist.
- Eine Schaltfläche mit der Beschriftung "Subscribe"
  
  Ihr Storyboard sollte nun folgendermaßen aussehen:
Erstellen Sie im Assistant Editor Outlets für alle Switches und nennen Sie diese "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch"

Erstellen Sie eine Aktion für Ihre Schaltfläche mit dem Namen subscribe. ViewController.h sollte den folgenden Code enthalten:

@property (weak, nonatomic) IBOutlet UISwitch *WorldSwitch;
@property (weak, nonatomic) IBOutlet UISwitch *PoliticsSwitch;
@property (weak, nonatomic) IBOutlet UISwitch *BusinessSwitch;
@property (weak, nonatomic) IBOutlet UISwitch *TechnologySwitch;
@property (weak, nonatomic) IBOutlet UISwitch *ScienceSwitch;
@property (weak, nonatomic) IBOutlet UISwitch *SportsSwitch;

- (IBAction)subscribe:(id)sender;

Erstellen Sie eine neue Cocoa Touch-Klasse namens Notifications. Fügen Sie den folgenden Code im Schnittstellenbereich der Datei Notifications.h ein:

@property NSData* deviceToken;

- (id)initWithConnectionString:(NSString*)listenConnectionString HubName:(NSString*)hubName;

- (void)storeCategoriesAndSubscribeWithCategories:(NSArray*)categories
            completion:(void (^)(NSError* error))completion;

- (NSSet*)retrieveCategories;

- (void)subscribeWithCategories:(NSSet*)categories completion:(void (^)(NSError *))completion;

Fügen Sie die folgende Import-Anweisung zu Notifications.h hinzu:
```
#import <WindowsAzureMessaging/WindowsAzureMessaging.h>
```

Fügen Sie den folgenden Code im Implementierungsbereich der Datei „Notifications.m“ ein.

SBNotificationHub* hub;

- (id)initWithConnectionString:(NSString*)listenConnectionString HubName:(NSString*)hubName{

    hub = [[SBNotificationHub alloc] initWithConnectionString:listenConnectionString
                                notificationHubPath:hubName];

    return self;
}

- (void)storeCategoriesAndSubscribeWithCategories:(NSSet *)categories completion:(void (^)(NSError *))completion {
    NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
    [defaults setValue:[categories allObjects] forKey:@"BreakingNewsCategories"];

    [self subscribeWithCategories:categories completion:completion];
}

- (NSSet*)retrieveCategories {
    NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];

    NSArray* categories = [defaults stringArrayForKey:@"BreakingNewsCategories"];

    if (!categories) return [[NSSet alloc] init];
    return [[NSSet alloc] initWithArray:categories];
}

- (void)subscribeWithCategories:(NSSet *)categories completion:(void (^)(NSError *))completion
{
    NSString* templateBodyAPNS = @"{\"aps\":{\"alert\":\"$(messageParam)\"}}";

    [hub registerTemplateWithDeviceToken:self.deviceToken name:@"simpleAPNSTemplate" 
        jsonBodyTemplate:templateBodyAPNS expiryTemplate:@"0" tags:categories completion:completion];
}

Diese Klasse verwendet den lokalen Speicher, um die Nachrichtenkategorien zu speichern und abzurufen, die das Gerät empfangen wird. Sie enthält außerdem eine Methode zum Registrieren dieser Kategorien mithilfe einer Vorlagenregistrierung .

Fügen Sie in der AppDelegate.h-Datei eine Importanweisung für Notifications.h und eine Eigenschaft für eine Instanz der Notifications-Klasse hinzu:
```
#import "Notifications.h"

@property (nonatomic) Notifications* notifications;
```
Fügen Sie in der didFinishLaunchingWithOptions-Methode in AppDelegate.m den Code zum Initialisieren der Notifications-Instanz am Anfang der Methode hinzu.
In HUBNAME und HUBLISTENACCESS (definiert in hubinfo.h) sollten die Platzhalter <hub name> und <connection string with listen access> bereits durch den Namen Ihres Notification Hubs und die Verbindungszeichenfolge für die zuvor abgerufene DefaultListenSharedAccessSignature ersetzt sein.
```
self.notifications = [[Notifications alloc] initWithConnectionString:HUBLISTENACCESS HubName:HUBNAME];
```
Hinweis

Da Anmeldenamen, die mit einer Client-App verteilt werden, nicht sehr sicher sind, sollten Sie nur den Schlüssel für den Abhörzugriff mit Ihrer Client-App verteilen. Der Abhörzugriff ermöglicht der App, sich für Benachrichtigungen zu registrieren, aber es können keine vorhandenen Registrierungen geändert und keine Benachrichtigungen versendet werden. Der Vollzugriffsschlüssel wird in einem gesicherten Back-End-Dienst für das Versenden von Benachrichtigungen und das Ändern vorhandener Benachrichtigungen verwendet.
Ersetzen Sie in der didRegisterForRemoteNotificationsWithDeviceToken-Methode in AppDelegate.m den Code in der Methode durch den folgenden Code, um das Gerätetoken an die notifications-Klasse zu übergeben. Die notifications-Klasse führt die Registrierung für Benachrichtigungen mit den Kategorien durch. Wenn der Benutzer die Auswahl der Kategorien ändert, wird die subscribeWithCategories-Methode als Antwort auf die Schaltfläche subscribe aufgerufen, um sie zu aktualisieren.

Hinweis

Da sich der durch den Apple Push Notification Service (APNS) zugeteilte Geräte-Token jederzeit ändern kann, sollten Sie sich regelmäßig für Benachrichtigungen registrieren, um Benachrichtigungsfehler zu vermeiden. Dieses Beispiel registriert sich jedes Mal für Benachrichtigungen, wenn die App gestartet wird. Für häufig ausgeführte Anwendungen (öfters als einmal täglich) können Sie die Registrierung wahrscheinlich überspringen, wenn weniger als ein Tag seit der letzten Registrierung vergangen ist, um Bandbreite einzusparen.
```
self.notifications.deviceToken = deviceToken;

// Retrieves the categories from local storage and requests a registration for these categories
// each time the app starts and performs a registration.

NSSet* categories = [self.notifications retrieveCategories];
[self.notifications subscribeWithCategories:categories completion:^(NSError* error) {
    if (error != nil) {
        NSLog(@"Error registering for notifications: %@", error);
    }
}];
```
Die Methode didRegisterForRemoteNotificationsWithDeviceToken sollte nun keinen anderen Code mehr enthalten.

Die folgenden Methoden sollten durch Abschließen des Tutorials Erste Schritte mit Notification Hubs bereits in AppDelegate.m vorhanden sein. Wenn dies nicht der Fall ist, fügen Sie sie hinzu.

- (void)MessageBox:(NSString *)title message:(NSString *)messageText
{

    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:title message:messageText delegate:self
        cancelButtonTitle:@"OK" otherButtonTitles: nil];
    [alert show];
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:
   (NSDictionary *)userInfo {
   NSLog(@"%@", userInfo);
   [self MessageBox:@"Notification" message:[[userInfo objectForKey:@"aps"] valueForKey:@"alert"]];
 }

Diese Methode verarbeitet Benachrichtigungen, die während der Ausführung der App empfangen werden, durch Anzeige eines einfachen UIAlert.

Fügen Sie in ViewController.m eine import-Anweisung für AppDelegate.h hinzu, und kopieren Sie den folgenden Code in die von XCode generierte subscribe-Methode. Dieser Code aktualisiert die Benachrichtigungsregistrierung so, dass die neuen Kategorietags verwendet werden, die der Benutzer auf der Benutzeroberfläche ausgewählt hat.

#import "Notifications.h"

NSMutableArray* categories = [[NSMutableArray alloc] init];

if (self.WorldSwitch.isOn) [categories addObject:@"World"];
if (self.PoliticsSwitch.isOn) [categories addObject:@"Politics"];
if (self.BusinessSwitch.isOn) [categories addObject:@"Business"];
if (self.TechnologySwitch.isOn) [categories addObject:@"Technology"];
if (self.ScienceSwitch.isOn) [categories addObject:@"Science"];
if (self.SportsSwitch.isOn) [categories addObject:@"Sports"];

Notifications* notifications = [(AppDelegate*)[[UIApplication sharedApplication]delegate] notifications];

[notifications storeCategoriesAndSubscribeWithCategories:categories completion: ^(NSError* error) {
    if (!error) {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:"Notification" message:"Subscribed" delegate:self
        cancelButtonTitle:@"OK" otherButtonTitles: nil];
        [alert show];
    } else {
        NSLog(@"Error subscribing: %@", error);
    }
}];

Diese Methode erstellt ein NSMutableArray mit Kategorien und verwendet die Klasse Notifications, um die Liste im lokalen Speicher zu speichern und die entsprechenden Tags bei Ihrem Benachrichtigungs-Hub zu registrieren. Wenn Kategorien geändert werden, wird die Registrierung mit neuen Kategorien neu erstellt.

Fügen Sie in ViewController.m den folgenden Code in der viewDidLoad-Methode hinzu, um die Benutzeroberfläche auf Grundlage der zuvor gespeicherten Kategorien festzulegen.

// This updates the UI on startup based on the status of previously saved categories.

Notifications* notifications = [(AppDelegate*)[[UIApplication sharedApplication]delegate] notifications];

NSSet* categories = [notifications retrieveCategories];

if ([categories containsObject:@"World"]) self.WorldSwitch.on = true;
if ([categories containsObject:@"Politics"]) self.PoliticsSwitch.on = true;
if ([categories containsObject:@"Business"]) self.BusinessSwitch.on = true;
if ([categories containsObject:@"Technology"]) self.TechnologySwitch.on = true;
if ([categories containsObject:@"Science"]) self.ScienceSwitch.on = true;
if ([categories containsObject:@"Sports"]) self.SportsSwitch.on = true;

Die App kann jetzt verschiedene Kategorien im lokalen Speicher des Geräts speichern, die für die Registrierung beim Notification Hub verwendet werden, wenn die App gestartet wird. Der Benutzer kann zur Laufzeit die Auswahl der Kategorien ändern und auf die subscribe-Methode klicken, um die Registrierung für das Gerät zu aktualisieren. Als Nächstes aktualisieren Sie die App zum Senden von Benachrichtigungen zu aktuellen Nachrichten direkt in der App selbst.

(Optional) Senden von Benachrichtigungen mit Tags

Wenn Sie keinen Zugriff auf Visual Studio haben, können Sie den nächsten Abschnitt überspringen und Benachrichtigungen direkt über die App senden. Sie können auch die richtige Vorlagenbenachrichtigung aus dem Azure-Portal mithilfe der Registerkarte „Debuggen“ für den Notification Hub senden.

In diesem Abschnitt senden Sie Neuigkeiten als Vorlagenbenachrichtigungen mit Tags über eine .NET-Konsolen-App.

Erstellen Sie in Visual Studio eine neue Visual C#-Konsolenanwendung:
1. Wählen Sie im Menü die Optionen Datei>Neu>Projekt aus.
2. Wählen Sie unter Neues Projekt erstellen die Option Console App (.NET Framework) (Konsolen-App (.NET Framework)) für C# in der Liste der Vorlagen und dann Weiter aus.
3. Geben Sie einen Namen für die App ein.
4. Wählen Sie für Projektmappe die Option Zur Projektmappe hinzufügen aus, und wählen Sie dann Erstellen aus, um das Projekt zu erstellen.
Wählen Sie die Optionen Extras>NuGet-Paket-Manager>Paket-Manager-Konsole aus, und führen Sie im Konsolenfenster den folgenden Befehl aus:
```
Install-Package Microsoft.Azure.NotificationHubs
```
Dadurch wird mithilfe des Microsoft.Azure.NotificationHubs-Pakets ein Verweis auf das Azure Notification Hubs-SDK hinzugefügt.
Öffnen Sie die Datei Program.cs, und fügen Sie die folgende using-Anweisung hinzu:
```
using Microsoft.Azure.NotificationHubs;
```

Fügen Sie in der Program -Klasse die folgende Methode hinzu, oder ersetzen Sie sie, falls sie bereits vorhanden ist:

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

Dieser Code sendet eine Vorlagenbenachrichtigung für jedes der sechs Tags im Zeichenfolgenarray. Durch die Verwendung von Tags wird sichergestellt, dass Geräte nur Benachrichtigungen für die registrierten Kategorien erhalten.

Ersetzen Sie im obigen Code die Platzhalter <hub name> und <connection string with full access> durch den Namen Ihres Notification Hubs und die Verbindungszeichenfolge für DefaultFullSharedAccessSignature aus dem Dashboard für Ihren Notification Hub.
Fügen Sie in der Main()-Methode die folgenden Zeilen hinzu:
```
 SendTemplateNotificationAsync();
 Console.ReadLine();
```
Erstellen Sie die Konsolenanwendung.

(Optional) Senden von Benachrichtigungen vom Gerät

Normalerweise würden die Benachrichtigungen von einem Back-End-Dienst gesendet werden, aber Sie können Benachrichtigungen zu aktuellen Nachrichten direkt über die App senden. Dazu wird die SendNotificationRESTAPI-Methode aktualisiert, die im Tutorial Erste Schritte mit Notification Hubs definiert wurde.

Aktualisieren Sie in ViewController.m die SendNotificationRESTAPI-Methode wie folgt, sodass ein Parameter für das Kategorietag akzeptiert und die richtige Vorlagenbenachrichtigung gesendet wird.

- (void)SendNotificationRESTAPI:(NSString*)categoryTag
{
    NSURLSession* session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration
                                defaultSessionConfiguration] delegate:nil delegateQueue:nil];

    NSString *json;

    // Construct the messages REST endpoint
    NSURL* url = [NSURL URLWithString:[NSString stringWithFormat:@"%@%@/messages/%@", HubEndpoint,
                                        HUBNAME, API_VERSION]];

    // Generated the token to be used in the authorization header.
    NSString* authorizationToken = [self generateSasToken:[url absoluteString]];

    //Create the request to add the template notification message to the hub
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
    [request setHTTPMethod:@"POST"];

    // Add the category as a tag
    [request setValue:categoryTag forHTTPHeaderField:@"ServiceBusNotification-Tags"];

    // Template notification
    json = [NSString stringWithFormat:@"{\"messageParam\":\"Breaking %@ News : %@\"}",
            categoryTag, self.notificationMessage.text];

    // Signify template notification format
    [request setValue:@"template" forHTTPHeaderField:@"ServiceBusNotification-Format"];

    // JSON Content-Type
    [request setValue:@"application/json;charset=utf-8" forHTTPHeaderField:@"Content-Type"];

    //Authenticate the notification message POST request with the SaS token
    [request setValue:authorizationToken forHTTPHeaderField:@"Authorization"];

    //Add the notification message body
    [request setHTTPBody:[json dataUsingEncoding:NSUTF8StringEncoding]];

    // Send the REST request
    NSURLSessionDataTask* dataTask = [session dataTaskWithRequest:request
                completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
        {
        NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*) response;
            if (error || httpResponse.statusCode != 200)
            {
                NSLog(@"\nError status: %d\nError: %@", httpResponse.statusCode, error);
            }
            if (data != NULL)
            {
                //xmlParser = [[NSXMLParser alloc] initWithData:data];
                //[xmlParser setDelegate:self];
                //[xmlParser parse];
            }
        }];

    [dataTask resume];
}

Aktualisieren Sie in ViewController.m die Aktion Send Notification, wie im folgenden Code gezeigt. Dadurch werden die Benachrichtigungen gesendet, indem jedes Tag einzeln verwendet wird, und sie werden an mehrere Plattformen gesendet.

- (IBAction)SendNotificationMessage:(id)sender
{
    self.sendResults.text = @"";

    NSArray* categories = [NSArray arrayWithObjects: @"World", @"Politics", @"Business",
                            @"Technology", @"Science", @"Sports", nil];

    // Lets send the message as breaking news for each category to WNS, FCM, and APNS
    // using a template.
    for(NSString* category in categories)
    {
        [self SendNotificationRESTAPI:category];
    }
}

Erstellen Sie das Projekt neu, und stellen Sie sicher, dass keine Buildfehler vorliegen.

Ausführen der App und Erzeugen von Benachrichtigungen

Klicken Sie auf die Schaltfläche Ausführen, um das Projekt zu erstellen und die App zu starten. Wählen Sie einige Optionen zum Abonnieren aktueller Nachrichten aus, und klicken Sie dann auf die Schaltfläche Subscribe . Es sollte in einem Dialogfeld angegeben werden, dass die Benachrichtigungen abonniert wurden.

Wenn Sie Subscribeauswählen, konvertiert die App die ausgewählten Kategorien in Tags und fordert eine neue Geräteregistrierung für die ausgewählten Tags vom Notification Hub an.
Geben Sie eine Nachricht ein, die als aktuelle Nachricht gesendet werden soll, und klicken Sie dann auf die Schaltfläche Benachrichtigung senden . Führen Sie alternativ die .NET-Konsolen-App aus, um Benachrichtigungen zu generieren.
Jedes Gerät, das aktuelle Nachrichten abonniert hat, erhält die Benachrichtigungen, die Sie gerade gesendet haben.

Nächste Schritte

In diesem Tutorial haben Sie Broadcastbenachrichtigungen an bestimmte iOS-Geräte gesendet, die für die entsprechenden Kategorien registriert wurden. Um zu erfahren, wie Sie lokalisierte Pushbenachrichtigungen senden, fahren Sie mit dem folgenden Tutorial fort:

Senden von lokalisierten Pushbenachrichtigungen

Freigeben über