Samouczek: wysyłanie zlokalizowanych powiadomień wypychanych do systemu iOS przy użyciu usługi Azure Notification Hubs

Artykuł
06/01/2023

W tym samouczku pokazano, jak używać funkcji szablonów usługi Azure Notification Hubs do emitowania powiadomień o nowościach zlokalizowanych w języku i urządzeniu. W tym samouczku zaczniesz od aplikacji systemu iOS utworzonej w temacie Wysyłanie wiadomości o nowościach przy użyciu usługi Notification Hubs. Po zakończeniu możesz zarejestrować się w interesujących Cię kategoriach, określić język, w którym będą odbierane powiadomienia, i otrzymywać tylko powiadomienia wypychane dla wybranych kategorii w tym języku.

Ten scenariusz obejmuje dwie części:

Aplikacja systemu iOS umożliwia urządzeniom klienckim określanie języka i subskrybowanie różnych kategorii wiadomości powodujących niezgodność;
Zaplecze rozgłasza powiadomienia przy użyciu funkcji tagu i szablonu usługi Azure Notification Hubs.

W tym samouczku wykonasz następujące kroki:

Aktualizowanie interfejsu użytkownika aplikacji
Tworzenie aplikacji systemu iOS
Wysyłanie zlokalizowanych powiadomień szablonu z aplikacji konsolowej .NET
Wysyłanie zlokalizowanych powiadomień szablonu z urządzenia

Omówienie

W obszarze Wysyłanie wiadomości powodujących niezgodność w usłudze Notification Hubs utworzono aplikację, która używa tagów do subskrybowania powiadomień dla różnych kategorii wiadomości. Wiele aplikacji jest jednak przeznaczonych dla wielu rynków i wymaga lokalizacji. Oznacza to, że zawartość samych powiadomień musi być zlokalizowana i dostarczona do prawidłowego zestawu urządzeń. W tym samouczku pokazano, jak używać funkcji szablonu usługi Notification Hubs w celu łatwego dostarczania zlokalizowanych powiadomień o nowościach.

Uwaga

Jednym ze sposobów wysyłania zlokalizowanych powiadomień jest utworzenie wielu wersji każdego tagu. Na przykład do obsługi języka angielskiego, francuskiego i mandaryńskiego potrzebne byłyby trzy różne tagi dla wiadomości na świecie: "world_en", "world_fr" i "world_ch". Następnie należy wysłać zlokalizowaną wersję wiadomości na świecie do każdego z tych tagów. W tym temacie używasz szablonów, aby uniknąć rozprzestrzeniania się tagów i wymagania wysyłania wielu komunikatów.

Szablony umożliwiają określenie, w jaki sposób określone urządzenie powinno otrzymywać powiadomienie. Szablon określa dokładny format ładunku, odwołując się do właściwości stanowiących część komunikatu wysyłanego przez zaplecze aplikacji. W Twoim przypadku wysyłasz komunikat o ustawieniach regionalnych zawierający wszystkie obsługiwane języki:

{
    "News_English": "...",
    "News_French": "...",
    "News_Mandarin": "..."
}

Następnie upewnij się, że urządzenia rejestrują się przy użyciu szablonu, który odwołuje się do właściwej właściwości. Na przykład aplikacja systemu iOS, która chce zarejestrować się w francuskich rejestrach wiadomości przy użyciu następującej składni:

{
    aps: {
        alert: "$(News_French)"
    }
}

Aby uzyskać więcej informacji na temat szablonów, zobacz artykuł Templates (Szablony ).

Wymagania wstępne

Ukończ samouczek Wysyłanie powiadomień wypychanych do określonych urządzeń z systemem iOS i udostępnia kod, ponieważ ten samouczek jest kompilujący się bezpośrednio na tym kodzie.
Program Visual Studio 2019 jest opcjonalny.

Aktualizowanie interfejsu użytkownika aplikacji

W tej sekcji zmodyfikujesz aplikację Breaking News utworzoną w temacie Używanie usługi Notification Hubs do wysyłania wiadomości powodujących niezgodność w celu wysyłania zlokalizowanych wiadomości powodujących niezgodność przy użyciu szablonów.

W pliku MainStoryboard_iPhone.storyboarddodaj kontrolkę Segmented z trzema językami: angielskim, francuskim i mandaryńskim.

Tworzenie scenorysu interfejsu użytkownika systemu iOS

Następnie dodaj element IBOutlet w pliku ViewController.h, jak pokazano na poniższej ilustracji:

Tworzenie gniazd dla przełączników

Tworzenie aplikacji systemu iOS

W pliku Notification.hdodaj metodę retrieveLocale i zmodyfikuj metody magazynu i subskrybowania, jak pokazano w poniższym kodzie:

- (void) storeCategoriesAndSubscribeWithLocale:(int) locale categories:(NSSet*) categories completion: (void (^)(NSError* error))completion;

- (void) subscribeWithLocale:(int) locale categories:(NSSet*) categories completion:(void (^)(NSError *))completion;

- (NSSet*) retrieveCategories;

- (int) retrieveLocale;

Notification.mW pliku zmodyfikuj metodę storeCategoriesAndSubscribe , dodając locale parametr i przechowując go w wartościach domyślnych użytkownika:

- (void) storeCategoriesAndSubscribeWithLocale:(int) locale categories:(NSSet *)categories completion:(void (^)(NSError *))completion {
    NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];
    [defaults setValue:[categories allObjects] forKey:@"BreakingNewsCategories"];
    [defaults setInteger:locale forKey:@"BreakingNewsLocale"];
    [defaults synchronize];

    [self subscribeWithLocale: locale categories:categories completion:completion];
}

Następnie zmodyfikuj metodę subskrybowania , aby uwzględnić ustawienia regionalne:

- (void) subscribeWithLocale: (int) locale categories:(NSSet *)categories completion:(void (^)(NSError *))completion{
    SBNotificationHub* hub = [[SBNotificationHub alloc] initWithConnectionString:@"<connection string>" notificationHubPath:@"<hub name>"];

    NSString* localeString;
    switch (locale) {
        case 0:
            localeString = @"English";
            break;
        case 1:
            localeString = @"French";
            break;
        case 2:
            localeString = @"Mandarin";
            break;
    }

    NSString* template = [NSString stringWithFormat:@"{\"aps\":{\"alert\":\"$(News_%@)\"},\"inAppMessage\":\"$(News_%@)\"}", localeString, localeString];

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

Zamiast registerNativeWithDeviceTokenmetody należy użyć metody registerTemplateWithDeviceToken. Podczas rejestrowania się w celu utworzenia szablonu należy podać szablon JSON, a także nazwę szablonu (ponieważ aplikacja może chcieć zarejestrować różne szablony). Pamiętaj, aby zarejestrować swoje kategorie jako tagi, ponieważ chcesz otrzymywać powiadomienia dotyczące tych wiadomości.

Dodaj metodę , aby pobrać ustawienia regionalne z ustawień domyślnych użytkownika:

- (int) retrieveLocale {
    NSUserDefaults* defaults = [NSUserDefaults standardUserDefaults];

    int locale = [defaults integerForKey:@"BreakingNewsLocale"];

    return locale < 0?0:locale;
}

Teraz, po zmodyfikowaniu Notifications klasy, musisz upewnić się, że ViewController funkcja korzysta z nowego UISegmentControlelementu . Dodaj następujący wiersz w metodzie , viewDidLoad aby upewnić się, że są wyświetlane aktualnie wybrane ustawienia regionalne:

self.Locale.selectedSegmentIndex = [notifications retrieveLocale];

Następnie w metodzie subscribe zmień wywołanie metody na storeCategoriesAndSubscribe następujący kod:

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

Na koniec musisz zaktualizować metodę didRegisterForRemoteNotificationsWithDeviceToken w aplikacji AppDelegate.m, aby można było poprawnie odświeżyć rejestrację po uruchomieniu aplikacji. Zmień wywołanie subscribe metody powiadomień przy użyciu następującego kodu:

NSSet* categories = [self.notifications retrieveCategories];
int locale = [self.notifications retrieveLocale];
[self.notifications subscribeWithLocale: locale categories:categories completion:^(NSError* error) {
    if (error != nil) {
        NSLog(@"Error registering for notifications: %@", error);
    }
}];

(opcjonalnie) Wysyłanie zlokalizowanych powiadomień szablonu z aplikacji konsolowej .NET

Podczas wysyłania powiadomień szablonu wystarczy podać tylko zestaw właściwości. W tym scenariuszu zestaw właściwości zawiera zlokalizowaną wersję bieżących wiadomości.

{
    "News_English": "World News in English!",
    "News_French": "World News in French!",
    "News_Mandarin": "World News in Mandarin!"
}

Wysyłanie powiadomień przy użyciu aplikacji konsolowej w języku C#

W tej sekcji przedstawiono sposób wysyłania powiadomień przy użyciu aplikacji konsolowej. Kod rozgłasza powiadomienia zarówno na urządzeniach Ze Sklepu Windows, jak i na urządzeniach z systemem iOS. Zmodyfikuj metodę SendTemplateNotificationAsync w poprzednio utworzonej aplikacji konsoli, korzystając z następującego kodu:

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

    // Sending the notification as a template notification. All template registrations that contain 
    // "messageParam" or "News_<local selected>" and the proper tags will receive the notifications. 
    // This includes APNS, GCM, WNS, and MPNS template registrations.
    Dictionary<string, string> templateParams = new Dictionary<string, string>();

    // Create an array of breaking news categories.
    var categories = new string[] { "World", "Politics", "Business", "Technology", "Science", "Sports"};
    var locales = new string[] { "English", "French", "Mandarin" };

    foreach (var category in categories)
    {
        templateParams["messageParam"] = "Breaking " + category + " News!";

        // Sending localized News for each tag too...
        foreach( var locale in locales)
        {
            string key = "News_" + locale;

            // Your real localized news content would go here.
            templateParams[key] = "Breaking " + category + " News in " + locale + "!";
        }

        await hub.SendTemplateNotificationAsync(templateParams, category);
    }
}

Metoda SendTemplateNotificationAsync dostarcza zlokalizowany element wiadomości do wszystkich urządzeń niezależnie od platformy. Twoje centrum powiadomień kompiluje i dostarcza prawidłowy ładunek natywny do wszystkich urządzeń subskrybowanych do określonego tagu.

Wysyłanie powiadomień za pomocą usługi Mobile Services

W harmonogramie usługi Mobile Services użyj następującego skryptu:

var azure = require('azure');
var notificationHubService = azure.createNotificationHubService('<hub name>', '<connection string with full access>');
var notification = {
        "News_English": "World News in English!",
        "News_French": "World News in French!",
        "News_Mandarin", "World News in Mandarin!"
}
notificationHubService.send('World', notification, function(error) {
    if (!error) {
        console.warn("Notification successful");
    }
});

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

Jeśli nie masz dostępu do programu Visual Studio lub chcesz po prostu przetestować wysyłanie zlokalizowanych powiadomień szablonu bezpośrednio z aplikacji na urządzeniu. Parametry zlokalizowanego szablonu można dodać do SendNotificationRESTAPI metody zdefiniowanej w poprzednim samouczku.

- (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 : %@\","
            \"News_English\":\"Breaking %@ News in English : %@\","
            \"News_French\":\"Breaking %@ News in French : %@\","
            \"News_Mandarin\":\"Breaking %@ News in Mandarin : %@\","
            categoryTag, self.notificationMessage.text,
            categoryTag, self.notificationMessage.text,  // insert English localized news here
            categoryTag, self.notificationMessage.text,  // insert French localized news here
            categoryTag, self.notificationMessage.text]; // insert Mandarin localized news here

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

Następne kroki

W tym samouczku wysłano zlokalizowane powiadomienia do urządzeń z systemem iOS. Aby dowiedzieć się, jak wypychać powiadomienia do określonych użytkowników aplikacji systemu iOS, przejdź do następującego samouczka:

Wypychanie powiadomień do konkretnych użytkowników

Udostępnij za pośrednictwem