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

Artykuł
04/20/2023

Omówienie

W tym samouczku pokazano, jak używać usługi Azure Notification Hubs do emisji powiadomień o aktualnościach do aplikacji systemu iOS. Po zakończeniu możesz zarejestrować się w celu uzyskania interesujących Cię kategorii wiadomości i otrzymywać tylko powiadomienia wypychane dla tych kategorii. Ten scenariusz jest typowym wzorcem dla wielu aplikacji wymagających wysyłania powiadomień do grup użytkowników, które wcześniej zadeklarowały zainteresowanie nimi, na przykład czytników danych RSS, aplikacji dla fanów muzyki itp.

Scenariusze rozgłaszania są włączone w przypadku co najmniej jednego tagu podczas tworzenia rejestracji w centrum powiadomień. Po wysłaniu powiadomień do tagu urządzenia zarejestrowane dla tagu otrzymają powiadomienie. Tagi to po prostu ciągi, dlatego nie muszą być aprowizowane z wyprzedzeniem. Aby uzyskać więcej informacji na temat tagów, zobacz Notification Hubs Routing and Tag Expressions (Wyrażenia routingu i tagów w usłudze Notification Hubs).

W tym samouczku wykonasz następujące kroki:

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

Wymagania wstępne

Ten temat opiera się na aplikacji utworzonej w artykule Samouczek: wysyłanie powiadomień wypychanych do aplikacji systemu iOS przy użyciu usługi Azure Notification Hubs. Przed rozpoczęciem tego samouczka musisz mieć już ukończony samouczek: wysyłanie powiadomień wypychanych do aplikacji systemu iOS przy użyciu usługi Azure Notification Hubs.

Dodawanie wyboru kategorii do aplikacji

Pierwszym krokiem jest dodanie elementów interfejsu użytkownika do istniejącego scenorysu, który umożliwia użytkownikowi wybieranie kategorii do zarejestrowania. Kategorie wybrane przez użytkownika są przechowywane na urządzeniu. Po uruchomieniu aplikacji w centrum powiadomień zostanie utworzona rejestracja urządzenia z wybranymi kategoriami w formie tagów.

W MainStoryboard_iPhone.storyboard dodaj następujące składniki z biblioteki obiektów:
- Etykieta z tekstem "Breaking News",
- Etykiety z kategoriami tekstów "World", "Politics", "Business", "Technology", "Science", "Sports",
- Sześć przełączników, jeden na kategorię, ustaw domyślnie wartość Wyłącz każdy stan przełącznika.
- Jeden przycisk z etykietą "Subskrybuj"
  
  Scenorys powinien wyglądać następująco:
W edytorze asystenta utwórz punkty dla wszystkich przełączników i nazywają 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ę importu do pliku 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ę rejestrowania dla tych kategorii przy użyciu rejestracji szablonu .

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

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

Ponieważ poświadczenia dystrybuowane przy użyciu aplikacji klienckiej nie są zazwyczaj bezpieczne, należy przy użyciu aplikacji klienckiej dystrybuować 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.
W metodzie didRegisterForRemoteNotificationsWithDeviceToken w AppDelegate.mpliku zastąp kod w metodzie następującym kodem, aby przekazać token urządzenia do notifications klasy. Klasa notifications wykonuje rejestrację w celu otrzymywania powiadomień z kategoriami. Jeśli użytkownik zmieni wybrane kategorie, 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ąć niepowodzeń powiadomień. Poniższy przykład przeprowadza rejestrację w celu otrzymywania powiadomień za każdym razem, gdy aplikacja jest uruchamiana. W przypadku często uruchamianych aplikacji — więcej niż raz dziennie — prawdopodobnie możesz pominąć rejestrację, aby zachować przepustowość, jeśli od poprzedniej rejestracji upłynął czas krótszy 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 nie powinien istnieć żaden inny kod w metodzie didRegisterForRemoteNotificationsWithDeviceToken .

Poniższe metody powinny być już dostępne od AppDelegate.m 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 odbierane po uruchomieniu aplikacji, wyświetlając prosty interfejs użytkownikaAlert.

W ViewController.mpliku dodaj instrukcję import dla AppDelegate.h polecenia i skopiuj następujący kod do metody wygenerowanej subscribe 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 kategorie i używa Notifications klasy do przechowywania listy w magazynie lokalnym i rejestruje odpowiednie tagi w centrum powiadomień. Jeśli kategorie zostaną zmienione, rejestracja zostanie ponownie utworzona przy użyciu nowych kategorii.

W ViewController.mpliku dodaj następujący kod w metodzie viewDidLoad , aby ustawić interfejs użytkownika na podstawie poprzednio 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 czasie wykonywania i kliknąć subscribe metodę, 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 otagowanych powiadomień

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 Azure Portal przy użyciu karty debugowania centrum powiadomień.

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

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.
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 .
Otwórz plik Program.cs i dodaj następującą using instrukcję:
```
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 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.

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ń.

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

 SendTemplateNotificationAsync();
 Console.ReadLine();

Skompiluj aplikację konsoli.

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

Zwykle powiadomienia będą wysyłane przez usługę zaplecza, ale można wysyłać powiadomienia o aktualnościach bezpośrednio z aplikacji. W tym celu zaktualizujesz metodę zdefiniowaną SendNotificationRESTAPI w samouczku Wprowadzenie do usługi Notification Hubs .

W ViewController.mpliku zaktualizuj metodę SendNotificationRESTAPI w następujący sposób, aby akceptowała parametr tagu kategorii i wysyła odpowiednie powiadomienie o szablonie .

- (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.mpliku zaktualizuj Send Notification akcję, jak pokazano w poniższym kodzie. Dzięki temu powiadomienia są wysyłane pojedynczo 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];
    }
}

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

Uruchamianie aplikacji i generowanie powiadomień

Kliknij przycisk Uruchom, aby skompilować projekt i uruchomić aplikację. Wybierz kilka opcji wiadomości powodujących niezgodność, aby zasubskrybować, a następnie naciśnij przycisk Subskrybuj . Powinno zostać wyświetlone okno dialogowe wskazujące, że powiadomienia zostały zasubskrybowane.

Po wybraniu pozycji Subskrybuj aplikacja 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 powodujące niezgodność, a następnie naciśnij przycisk Wyślij powiadomienie . Alternatywnie uruchom aplikację konsolową platformy .NET, aby wygenerować powiadomienia.
Każde urządzenie zasubskrybowane do wiadomości przełomowych otrzymuje właśnie wysłane powiadomienia o nowościach.

Następne kroki

W tym samouczku wysłano powiadomienia o emisji do określonych urządzeń z systemem iOS zarejestrowanych dla kategorii. Aby dowiedzieć się, jak wypychać zlokalizowane powiadomienia, przejdź do następującego samouczka:

Wypychanie powiadomień zlokalizowanych

Udostępnij za pośrednictwem