Samouczek: wysyłanie powiadomień push do określonych urządzeń z systemem iOS przy użyciu Azure Notification Hubs

2025-04-01

Przegląd

W tym samouczku pokazano, jak korzystać z usługi Azure Notification Hubs do wysyłania powiadomień z najnowszymi wiadomościami do aplikacji systemu iOS. Po zakończeniu będziesz mógł zarejestrować się w celu wyboru interesujących Cię kategorii wiadomości i otrzymywać tylko powiadomienia push dla tych kategorii. Ten scenariusz jest typowym wzorcem dla wielu aplikacji, w których powiadomienia muszą być wysyłane do grup użytkowników, którzy wcześniej zadeklarowali zainteresowanie nimi, na przykład czytnika RSS, aplikacji dla fanów muzyki itp.

Scenariusze transmisji są aktywowane poprzez uwzględnienie co najmniej jednego tagu i przy tworzeniu rejestracji w centrum powiadomień. Gdy powiadomienia są wysyłane do tagu, urządzenia zarejestrowane dla tagu otrzymają powiadomienie. Ponieważ tagi są po prostu ciągami, nie muszą być aprowizowane z wyprzedzeniem. Aby uzyskać więcej informacji na temat tagów, zobacz Notification Hubs Routing and Tag Expressions.

W tym samouczku wykonasz następujące kroki:

Dodawanie wyboru kategorii do aplikacji
Wysyłanie powiadomień oznakowanych
Wysyłanie powiadomień z urządzenia
Uruchamianie aplikacji i generowanie powiadomień

Wymagania wstępne

To zagadnienie opiera się na aplikacji, którą utworzyłeś w Samouczek: wysyłanie powiadomień push do aplikacji iOS przy użyciu usługi Azure Notification Hubs. Przed rozpoczęciem tego samouczka musisz już ukończyć Samouczek: powiadomienia push do aplikacji iOS za pomocą Azure Notification Hubs.

Dodawanie wyboru kategorii do aplikacji

Pierwszym krokiem jest dodanie elementów interfejsu użytkownika do istniejącego scenorysu, który umożliwi użytkownikowi wybranie kategorii do zarejestrowania. Kategorie wybrane przez użytkownika są przechowywane na urządzeniu. Po uruchomieniu aplikacji rejestracja urządzenia jest tworzona w centrum powiadomień z wybranymi kategoriami jako tagami.

W MainStoryboard_iPhone.storyboard dodaj następujące komponenty z biblioteki obiektów:
- Etykieta z tekstem "Breaking News",
- Etykiety z tekstami kategorii "World", "Politics", "Business", "Technology", "Science", "Sports",
- Sześć przełączników, po jednym na kategorię, każdy przełącznik State domyślnie ustawić na wyłączyć.
- Jeden przycisk z etykietą "Subskrybuj"
  
  Scenorys powinien wyglądać następująco:
W edytorze asystenta utwórz odwołania dla wszystkich przełączników i nazwij je "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch"

Utwórz akcję dla przycisku o nazwie subscribe; ViewController.h powinien zawierać następujący kod:

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

Utwórz nową klasę Cocoa Touch o nazwie Notifications. Skopiuj następujący kod w sekcji interfejsu pliku 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;

Dodaj następującą dyrektywę importowania do usługi Notifications.m:
```
#import <WindowsAzureMessaging/WindowsAzureMessaging.h>
```

Skopiuj następujący kod w sekcji implementacji pliku 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];
}

Ta klasa używa magazynu lokalnego do przechowywania i pobierania kategorii wiadomości odbieranych przez to urządzenie. Zawiera również metodę rejestracji dla tych kategorii przy użyciu rejestracji według szablonu .

W pliku AppDelegate.h dodaj instrukcję importowania dla Notifications.h i dodaj właściwość dla wystąpienia klasy Notifications:
```
#import "Notifications.h"

@property (nonatomic) Notifications* notifications;
```
W metodzie didFinishLaunchingWithOptions w AppDelegate.mdodaj kod, aby zainicjować wystąpienie powiadomień na początku metody.
HUBNAME i HUBLISTENACCESS (zdefiniowane w hubinfo.h) powinny mieć już symbole zastępcze <hub name> i <connection string with listen access> zastąpione nazwą centrum powiadomień oraz parametrami połączenia dla DefaultListenSharedAccessSignature uzyskanymi wcześniej
```
self.notifications = [[Notifications alloc] initWithConnectionString:HUBLISTENACCESS HubName:HUBNAME];
```
Uwaga

Ponieważ poświadczenia dystrybuowane z aplikacją kliencką nie są ogólnie bezpieczne, należy rozpowszechnić tylko klucz na potrzeby dostępu do nasłuchiwania za pomocą aplikacji klienckiej. Dostęp do nasłuchiwania umożliwia aplikacji rejestrowanie się w celu otrzymywania powiadomień, ale nie można modyfikować istniejących rejestracji i nie można wysyłać powiadomień. Pełny klucz dostępu jest używany w zabezpieczonej usłudze zaplecza do wysyłania powiadomień i zmieniania istniejących rejestracji.
W metodzie didRegisterForRemoteNotificationsWithDeviceToken w AppDelegate.mzastąp kod w metodzie poniższym kodem, aby przekazać token urządzenia do klasy notifications. Klasa notifications wykonuje rejestrowanie powiadomień w kategoriach. Jeśli użytkownik zmieni wybór kategorii, wywołaj metodę subscribeWithCategories w odpowiedzi na przycisk subskrybuj, aby je zaktualizować.

Uwaga

Ponieważ token urządzenia przypisany przez usługę Apple Push Notification Service (APNS) może ulec zmianie w dowolnym momencie, należy zarejestrować się w celu częstego rejestrowania powiadomień, aby uniknąć błędów powiadomień. W tym przykładzie aplikacja rejestruje się do otrzymywania powiadomień za każdym razem, gdy zostanie uruchomiona. W przypadku aplikacji, które są uruchamiane często, więcej niż raz dziennie, prawdopodobnie możesz pominąć rejestrację, aby zachować przepustowość, jeśli od poprzedniej rejestracji upłynął mniej niż jeden dzień.
```
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);
    }
}];
```
W tym momencie w metodzie didRegisterForRemoteNotificationsWithDeviceToken nie powinien istnieć żaden inny kod.

Poniższe metody powinny już być obecne w AppDelegate.m od ukończenia samouczka Rozpoczynanie pracy z usługą Notification Hubs. Jeśli nie, dodaj 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"]];
 }

Ta metoda obsługuje powiadomienia odebrane po uruchomieniu aplikacji przez wyświetlenie prostego interfejsu użytkownikaAlert.

W ViewController.mdodaj instrukcję import dla AppDelegate.h i skopiuj następujący kod do metody subscribe wygenerowanej przez program XCode. Ten kod aktualizuje rejestrację powiadomień, aby używać nowych tagów kategorii wybranych przez użytkownika w interfejsie użytkownika.

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

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

W ViewController.mdodaj następujący kod w metodzie viewDidLoad, aby ustawić interfejs użytkownika na podstawie wcześniej zapisanych kategorii.

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

Aplikacja może teraz przechowywać zestaw kategorii w magazynie lokalnym urządzenia używanym do rejestrowania się w centrum powiadomień za każdym razem, gdy aplikacja zostanie uruchomiona. Użytkownik może zmienić wybór kategorii w trakcie działania programu i kliknąć metodę subscribe, aby zaktualizować rejestrację urządzenia. Następnie zaktualizujesz aplikację, aby wysyłała powiadomienia o nowościach bezpośrednio w samej aplikacji.

(opcjonalnie) Wysyłanie powiadomień oznakowanych

Jeśli nie masz dostępu do programu Visual Studio, możesz przejść do następnej sekcji i wysłać powiadomienia z samej aplikacji. Możesz również wysłać odpowiednie powiadomienie szablonu z portalu Azure przy użyciu karty debug dla centrum powiadomień.

W tej sekcji wyślesz istotne wiadomości jako powiadomienia o oznakowanym szablonie z aplikacji konsolowej platformy .NET.

W programie Visual Studio utwórz nową aplikację konsolową visual C#:
1. Z menu wybierz plik>nowy>projekt.
2. W Utwórz nowy projektwybierz 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. Dla rozwiązania wybierz Dodaj do rozwiązaniai wybierz Utwórz, aby utworzyć projekt.
Wybierz Tools>NuGet Package Manager>Package Manager Console, 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.
Otwórz plik Program.cs i dodaj następującą instrukcję using:
```
using Microsoft.Azure.NotificationHubs;
```

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 według szablonu dla każdego z sześciu tagów w tablicy ciągów. Użycie tagów gwarantuje, że urządzenia otrzymają powiadomienia tylko dla zarejestrowanych kategorii.

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

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

 SendTemplateNotificationAsync();
 Console.ReadLine();

Skompiluj aplikację konsolową.

(opcjonalnie) Wysyłanie powiadomień z urządzenia

Zwykle powiadomienia są wysyłane przez usługę zaplecza, ale powiadomienia o nowościach można wysyłać bezpośrednio z aplikacji. W tym celu zaktualizujesz metodę SendNotificationRESTAPI zdefiniowaną w samouczku Rozpoczynanie pracy z usługą Notification Hubs.

W ViewController.mzaktualizuj metodę SendNotificationRESTAPI w następujący sposób, aby akceptowała parametr dla tagu kategorii oraz wysyłała odpowiedni szablon powiadomienia.

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

W ViewController.mzaktualizuj akcję Send Notification, jak pokazano w poniższym kodzie. Dzięki temu powiadomienia są wysyłane indywidualnie przy użyciu każdego tagu i wysyłane do wielu platform.

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

Odbuduj projekt i upewnij się, że nie masz błędów kompilacji.

Uruchamianie aplikacji i generowanie powiadomień

Naciśnij przycisk Uruchom, aby skompilować projekt i uruchomić aplikację. Wybierz kilka opcji aktualności, aby zasubskrybować, a następnie naciśnij przycisk Subskrybuj. Powinno zostać wyświetlone okno dialogowe z informacją, że powiadomienia zostały zasubskrybowane.

Po wybraniu opcji Subskrybujaplikacja konwertuje wybrane kategorie na tagi i żąda nowej rejestracji urządzenia dla wybranych tagów z centrum powiadomień.
Wprowadź wiadomość, która ma zostać wysłana jako wiadomości z ostatniej chwili, a następnie naciśnij przycisk Wyślij powiadomienie. Alternatywnie uruchom aplikację konsolową .NET, aby wygenerować powiadomienia.
Każde urządzenie subskrybowane do wiadomości o aktualnościach otrzymuje właśnie wysłane powiadomienia o nowościach.

Następne kroki

W tym samouczku wysyłano powiadomienia do określonych urządzeń z systemem iOS, które zarejestrowały się do kategorii. Aby dowiedzieć się, jak przekazywać lokalizowane powiadomienia, przejdź do kolejnego poradnika.

Wysyłanie zlokalizowanych powiadomień push