Kurz: Odesílání nabízených oznámení konkrétním zařízením s iOSem pomocí služby Azure Notification Hubs

Článek
04/20/2023

Přehled

V tomto kurzu se dozvíte, jak používat Azure Notification Hubs k vysílání oznámení o nejnovějších zprávách do aplikace pro iOS. Po dokončení se můžete zaregistrovat do kategorií nejnovějších zpráv, které vás zajímají, a přijímat jenom nabízená oznámení pro tyto kategorie. Tento scénář se běžně používá v řadě aplikací, které posílají oznámení skupinám uživatelům, kteří o ně projevili zájem. Může jít třeba o čtečku RSS, aplikaci pro hudební fanoušky atd.

Scénáře vysílání povolíte tak, že při registraci v centru oznámení přidáte jednu nebo více značek. Když se do značky odešlou oznámení, zařízení, která jsou pro značku zaregistrovaná, obdrží oznámení. Značky jsou jednoduše řetězce, které se nemusejí vytvářet předem. Další informace o značkách najdete v článku Směrování a výrazy značek ve službě Notification Hubs.

V tomto kurzu provedete následující kroky:

Přidání výběru kategorie do aplikace
Posílání označených oznámení
Odesílání oznámení ze zařízení
Spuštění aplikace a generování oznámení

Požadavky

Toto téma vychází z aplikace, kterou jste vytvořili v kurzu: Nabízená oznámení aplikacím pro iOS pomocí služby Azure Notification Hubs. Před zahájením tohoto kurzu už musíte mít dokončený Kurz: Nabízená oznámení aplikacím pro iOS pomocí služby Azure Notification Hubs.

Přidání výběru kategorií do aplikace

Prvním krokem je přidání prvků uživatelského rozhraní do existujícího scénáře, které uživateli umožní vybrat kategorie k registraci. Kategorie, které uživatel vybere, jsou uložené v zařízení. Při spuštění aplikace se v centru oznámení provede registrace zařízení s vybranými kategoriemi ve formě značek.

Do MainStoryboard_iPhone.storyboard přidejte z knihovny objektů následující komponenty:
- Popisek s textem "Nejnovější zprávy",
- Popisky s texty kategorií "Svět", "Politika", "Podnikání", "Technologie", "Věda", "Sport",
- Šest přepínačů , jeden na kategorii, nastaví každý stav přepínače na Vypnuto ve výchozím nastavení.
- Jedno tlačítko označené jako "Přihlásit k odběru"
  
  Scénář by měl vypadat takto:
V editoru asistentů vytvořte zásuvky pro všechny přepínače a nazvěte je "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch".

Vytvořte akci pro tlačítko s názvem subscribe; ViewController.h měla by obsahovat následující kód:

@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;

Vytvořte novou třídu Cocoa Touch s názvem Notifications. Zkopírujte následující kód v části rozhraní souboru Notifications.h:

@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;

Do Notification.m přidejte následující direktivu importu:
```
#import <WindowsAzureMessaging/WindowsAzureMessaging.h>
```

Zkopírujte následující kód v části implementace souboru Notifications.m.

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

Tato třída používá místní úložiště k ukládání a načítání kategorií zpráv, které toto zařízení přijímá. Obsahuje také metodu pro registraci těchto kategorií pomocí registrace šablony .

AppDelegate.h Do souboru přidejte příkaz importu pro Notifications.h a přidejte vlastnost pro instanci Notifications třídy:
```
#import "Notifications.h"

@property (nonatomic) Notifications* notifications;
```
didFinishLaunchingWithOptions V metodě v AppDelegate.msouboru přidejte kód pro inicializaci instance oznámení na začátku metody.
HUBNAME a HUBLISTENACCESS (definované v hubinfo.h) by už měly mít <hub name> zástupné symboly a <connection string with listen access> nahrazené názvem vašeho centra oznámení a připojovací řetězec pro DefaultListenSharedAccessSignature , který jste získali dříve.
```
self.notifications = [[Notifications alloc] initWithConnectionString:HUBLISTENACCESS HubName:HUBNAME];
```
Poznámka

Obecně platí, že přihlašovací údaje distribuované klientskou aplikací nejsou příliš bezpečné, a proto byste měli s klientskou aplikací distribuovat jenom přístupový klíč pro naslouchání. Přístup pro naslouchání umožňuje aplikaci registrovat oznámení, ale nedovolí měnit stávající registrace ani odesílat oznámení. Plný přístupový klíč se používá v zabezpečené back-endové službě k posílání oznámení a změně stávajících registrací.
didRegisterForRemoteNotificationsWithDeviceToken V metodě v AppDelegate.msouboru nahraďte kód v metodě následujícím kódem pro předání tokenu zařízení do notifications třídy. Třída notifications provádí registraci oznámení pomocí kategorií. Pokud uživatel změní výběry kategorií, zavolejte metodu subscribeWithCategories v reakci na tlačítko přihlásit k odběru a aktualizujte je.

Poznámka

Vzhledem k tomu, že token zařízení přiřazený službou Apple Push Notification Service (APNS) se může kdykoli změnit, měli byste se k oznámením často registrovat, abyste se vyhnuli chybám oznámení. V tomto příkladu se oznámení registrují při každém spuštění aplikace. Pokud se aplikace spouštějí často, třeba častěji než jednou denně, pravděpodobně můžete registraci přeskočit kvůli úspoře šířky pásma, protože od předchozí registrace neuplynul ani den.
```
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);
    }
}];
```
V tomto okamžiku by v didRegisterForRemoteNotificationsWithDeviceToken metodě neměl být žádný jiný kód.

Následující metody by už měly být k dispozici od AppDelegate.m dokončení kurzu Začínáme s Notification Hubs . Pokud ne, přidejte je.

- (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"]];
 }

Tato metoda zpracovává oznámení přijatá při spuštění aplikace zobrazením jednoduchého uživatelského rozhraníAlert.

V ViewController.mpřidejte import příkaz pro AppDelegate.h a zkopírujte následující kód do metody generované subscribe XCode. Tento kód aktualizuje registraci oznámení tak, aby používala nové značky kategorií, které uživatel zvolil v uživatelském rozhraní.

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

Tato metoda vytvoří NSMutableArray kategorii kategorií a použije Notifications třídu k uložení seznamu v místním úložišti a zaregistruje odpovídající značky v centru oznámení. Při změně kategorií se vytvoří registrace s novými kategoriemi.

V ViewController.mnástroji přidejte do viewDidLoad metody následující kód pro nastavení uživatelského rozhraní na základě dříve uložených kategorií.

// 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;

Aplikace teď může uložit sadu kategorií do místního úložiště zařízení, které se používá k registraci v centru oznámení při každém spuštění aplikace. Uživatel může změnit výběr kategorií za běhu a kliknutím na metodu subscribe aktualizovat registraci zařízení. Dále aplikaci aktualizujete tak, aby se oznámení o nejnovějších zprávách odesílala přímo v samotné aplikaci.

(volitelné) Odesílání oznámení se značkami

Pokud nemáte přístup k sadě Visual Studio, můžete přeskočit na další část a posílat oznámení ze samotné aplikace. Můžete také odeslat správné oznámení šablony z Azure Portal pomocí karty ladění pro vaše centrum oznámení.

V této části odešlete nejnovější zprávy jako šablonové oznámení se značkami z konzolové aplikace .NET.

Ve Visual Studiu vytvořte novou konzolovou aplikaci Visual C#:
1. V nabídce vyberte Soubor>nový>projekt.
2. V části Vytvořit nový projekt vyberte v seznamu šablon konzolová aplikace (.NET Framework) pro C# a vyberte Další.
3. Zadejte název aplikace.
4. V části Řešení zvolte Přidat do řešení a výběrem možnosti Vytvořit vytvořte projekt.
Vyberte Nástroje> Správcebalíčků> NuGetKonzola správce balíčků a pak v okně konzoly spusťte následující příkaz:
```
Install-Package Microsoft.Azure.NotificationHubs
```
Tato akce přidá odkaz na sadu Sdk služby Azure Notification Hubs pomocí balíčku Microsoft.Azure.NotificationHubs .
Otevřete soubor Program.cs a přidejte následující using příkaz:
```
using Microsoft.Azure.NotificationHubs;
```

Do třídy Program přidejte následující metodu, nebo ji nahraďte, pokud už existuje:

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

Tento kód odešle šablonové oznámení pro každou z šesti značek v poli řetězců. Použití značek zajišťuje, že zařízení budou přijímat oznámení jenom pro registrované kategorie.

V předchozím kódu nahraďte zástupné symboly <hub name> a <connection string with full access> názvem vašeho centra oznámení a připojovacím řetězcem pro DefaultFullSharedAccessSignature z řídicího panelu vašeho centra oznámení.

Main() Do metody přidejte následující řádky:

 SendTemplateNotificationAsync();
 Console.ReadLine();

Sestavte konzolovou aplikaci.

(volitelné) Odesílání oznámení ze zařízení

Za normálních okolností by oznámení posílala back-endová služba, ale oznámení o nejnovějších novinkách můžete posílat přímo z aplikace. Provedete to tak, že aktualizujete metodu SendNotificationRESTAPI , kterou jste definovali v kurzu Začínáme se službou Notification Hubs .

V ViewController.mnástroji aktualizujte metodu SendNotificationRESTAPI následujícím způsobem, aby přijala parametr pro značku category a odeslala správné oznámení šablony .

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

V ViewController.mnástroji Send Notification aktualizujte akci, jak je znázorněno v následujícím kódu. Tak, aby se oznámení odesílala pomocí každé značky jednotlivě a odeslala se na více platforem.

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

Znovu vytvořte projekt a ujistěte se, že nemáte žádné chyby sestavení.

Spuštění aplikace a generování oznámení

Stiskněte tlačítko Spustit a sestavte projekt a spusťte aplikaci. Vyberte některé možnosti nejnovějších zpráv, které chcete přihlásit k odběru, a pak stiskněte tlačítko Přihlásit k odběru . Mělo by se zobrazit dialogové okno s oznámením, že jste se přihlásili k odběru.

Když zvolíte Přihlásit se k odběru, aplikace převede vybrané kategorie na značky a požádá o registraci nového zařízení pro vybrané značky z centra oznámení.
Zadejte zprávu, která se má odeslat jako nejnovější zpráva, a pak stiskněte tlačítko Odeslat oznámení . Případně spusťte konzolovou aplikaci .NET a vygenerujte oznámení.
Každé zařízení přihlášené k odběru nejnovějších zpráv obdrží oznámení o nejnovějších zprávách, která jste právě odeslali.

Další kroky

V tomto kurzu jste odeslali vysílaná oznámení konkrétním zařízením s iOSem, která jsou zaregistrovaná do kategorií. Pokud chcete zjistit, jak odesílat lokalizovaná oznámení, přejděte k následujícímu kurzu:

Odesílání lokalizovaných oznámení