Esercitazione: Eseguire il push di notifiche a dispositivi iOS specifici con Hub di notifica di AzureTutorial: Push notifications to specific iOS devices using Azure Notification Hubs

OverviewOverview

In questa esercitazione viene illustrato come usare Hub di notifica di Azure per trasmettere le notifiche relative alle ultime notizie a un'app per iOS.This tutorial shows you how to use Azure Notification Hubs to broadcast breaking news notifications to an iOS app. Al termine si sarà appreso come effettuare la registrazione alle categorie di ultime notizie desiderate e ricevere le notifiche push solo da tali categorie.When complete, you are able to register for breaking news categories you are interested in, and receive only push notifications for those categories. Questo scenario è un modello comune per molte app nelle quali le notifiche devono essere inviate a gruppi di utenti che hanno dichiarato un interesse, ad esempio lettori di feed RSS, app per fan di musica e così via.This scenario is a common pattern for many apps where notifications have to be sent to groups of users that have previously declared interest in them, for example, RSS reader, apps for music fans, etc.

È possibile abilitare gli scenari di trasmissione includendo uno o più tag durante la creazione di una registrazione nell'hub di notifica.Broadcast scenarios are enabled by including one or more tags when creating a registration in the notification hub. Quando le notifiche vengono inviate a un tag, i dispositivi che hanno effettuato la registrazione per il tag ricevono la notifica.When notifications are sent to a tag, devices that have registered for the tag receive the notification. Poiché i tag sono costituiti da stringhe, non è necessario eseguire il provisioning anticipatamente.Because tags are simply strings, they do not have to be provisioned in advance. Per altre informazioni sui tag, vedere Espressioni di routing e tag per Hub di notifica.For more information about tags, see Notification Hubs Routing and Tag Expressions.

In questa esercitazione vengono completati i passaggi seguenti:In this tutorial, you take the following steps:

  • Aggiungere una selezione delle categorie all'appAdd a category selection to the app
  • Inviare notifiche con tagSend tagged notifications
  • Inviare notifiche dal dispositivoSend notifications from the device
  • Esecuzione dell'app e generazione di notificheRun the app and generate notifications

prerequisitiPrerequisites

Questo argomento si basa sull'app creata in esercitazione: notifiche push alle app iOS con hub di notifica di Azure.This topic builds on the app you created in Tutorial: Push notifications to iOS apps using Azure Notification Hubs. Prima di iniziare questa esercitazione, è necessario avere già completato l' esercitazione: notifiche push alle app iOS con hub di notifica di Azure.Before starting this tutorial, you must have already completed Tutorial: Push notifications to iOS apps using Azure Notification Hubs.

Aggiungere la selezione delle categorie all'appAdd category selection to the app

Il primo passaggio prevede l'aggiunta degli elementi dell'interfaccia utente allo storyboard esistente per consentire all'utente di selezionare le categorie per le quali registrarsi.The first step is to add the UI elements to your existing storyboard that enable the user to select categories to register. Le categorie selezionate da un utente sono archiviate nel dispositivo.The categories selected by a user are stored on the device. All'avvio dell'app, viene creata una registrazione del dispositivo nell'hub di notifica con le categorie selezionate come tag.When the app starts, a device registration is created in your notification hub with the selected categories as tags.

  1. Nel file MainStoryboard_iPhone.storyboard aggiungere i componenti seguenti dalla libreria di oggetti:In your MainStoryboard_iPhone.storyboard add the following components from the object library:

    • Un'etichetta con il testo "Breaking News".A label with "Breaking News" text,

    • Etichette con il testo relativo alle categorie "World", "Politics", "Business", "Technology", "Science", "Sports".Labels with category texts "World", "Politics", "Business", "Technology", "Science", "Sports",

    • Sei opzioni, una per ogni categoria, impostare lo stato di ogni opzione su Off per impostazione predefinita.Six switches, one per category, set each switch State to be Off by default.

    • Un pulsante con l'etichetta "Subscribe".One button labeled "Subscribe"

      L'aspetto dello storyboard dovrebbe essere simile al seguente:Your storyboard should look as follows:

      Strumento di creazione di interfaccia Xcode

  2. Nell'assistente dell'editor creare outlet per tutte le opzioni e denominarli "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch".In the assistant editor, create outlets for all the switches and call them "WorldSwitch", "PoliticsSwitch", "BusinessSwitch", "TechnologySwitch", "ScienceSwitch", "SportsSwitch"

  3. Creare un'azione per il pulsante denominato subscribe. Il file ViewController.h deve contenere il codice seguente:Create an Action for your button called subscribe; your ViewController.h should contain the following code:

    @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;
    
  4. Creare una nuova classe Cocoa Touch chiamata Notifications.Create a new Cocoa Touch Class called Notifications. Copiare il seguente codice nella sezione dell'interfaccia del file Notifications.h:Copy the following code in the interface section of the file 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;
    
  5. Aggiungere la seguente direttiva import a Notifications.m:Add the following import directive to Notifications.m:

    #import <WindowsAzureMessaging/WindowsAzureMessaging.h>
    
  6. Copiare il codice seguente nella sezione di implementazione del file Notifications.m:Copy the following code in the implementation section of the file 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
    {
        //[hub registerNativeWithDeviceToken:self.deviceToken tags:categories completion: completion];
    
        NSString* templateBodyAPNS = @"{\"aps\":{\"alert\":\"$(messageParam)\"}}";
    
        [hub registerTemplateWithDeviceToken:self.deviceToken name:@"simpleAPNSTemplate" 
            jsonBodyTemplate:templateBodyAPNS expiryTemplate:@"0" tags:categories completion:completion];
    }
    

    Questa classe usa l'archiviazione locale per archiviare e recuperare le categorie di notizie che il dispositivo deve ricevere.This class uses local storage to store and retrieve the categories of news that this device receives. Contiene inoltre un metodo per effettuare la registrazione per queste categorie tramite una registrazione Modello .Also, it contains a method to register for these categories using a Template registration.

  7. Nel file AppDelegate.h aggiungere un'istruzione import per Notifications.h e una proprietà per un'istanza della classe Notifications:In the AppDelegate.h file, add an import statement for Notifications.h and add a property for an instance of the Notifications class:

    #import "Notifications.h"
    
    @property (nonatomic) Notifications* notifications;
    
  8. Nel metodo didFinishLaunchingWithOptions in AppDelegate.m aggiungere il codice per inizializzare l'istanza di notifiche all'inizio del metodo.In the didFinishLaunchingWithOptions method in AppDelegate.m, add the code to initialize the notifications instance at the beginning of the method.
    HUBNAME e HUBLISTENACCESS (definiti in hubinfo.h) dovrebbero già avere i segnaposto <hub name> e <connection string with listen access> sostituiti con il nome dell'hub di notifica e la stringa di connessione per DefaultListenSharedAccessSignature ottenuta in precedenza.HUBNAME and HUBLISTENACCESS (defined in hubinfo.h) should already have the <hub name> and <connection string with listen access> placeholders replaced with your notification hub name and the connection string for DefaultListenSharedAccessSignature that you obtained earlier

    self.notifications = [[Notifications alloc] initWithConnectionString:HUBLISTENACCESS HubName:HUBNAME];
    

    Nota

    Poiché le credenziali che sono distribuite con un'app client in genere non sono sicure, distribuire solo la chiave per l'accesso Listen con l'app client.Because credentials that are distributed with a client app are not generally secure, you should only distribute the key for listen access with your client app. L'accesso Listen consente all'app di registrarsi per le notifiche ma le registrazioni esistenti non possono essere modificate e le notifiche non possono essere inviate.Listen access enables your app to register for notifications, but existing registrations cannot be modified and notifications cannot be sent. La chiave di accesso completa viene usata in un servizio back-end sicuro per l'invio delle notifiche e la modifica delle registrazioni esistenti.The full access key is used in a secured backend service for sending notifications and changing existing registrations.

  9. Nel metodo didRegisterForRemoteNotificationsWithDeviceToken in AppDelegate.m sostituire il codice nel metodo con il codice seguente per passare il token del dispositivo alla classe notifications.In the didRegisterForRemoteNotificationsWithDeviceToken method in AppDelegate.m, replace the code in the method with the following code to pass the device token to the notifications class. La classe notifications esegue la registrazione per le notifiche con le categorie.The notifications class performs the registering for notifications with the categories. Se l'utente modifica le selezioni delle categorie, chiamare il metodo subscribeWithCategories in risposta al pulsante sottoscrizione per aggiornarle.If the user changes category selections, call the subscribeWithCategories method in response to the subscribe button to update them.

    Nota

    Poiché il token di dispositivo assegnato dal servizio di notifica Push di Apple può cambiare in qualsiasi momento, è necessario ripetere la registrazione per le notifiche di frequente per evitare errori di notifica.Because the device token assigned by the Apple Push Notification Service (APNS) can chance at any time, you should register for notifications frequently to avoid notification failures. In questo esempio viene effettuata la registrazione per le notifiche a ogni avvio dell'app.This example registers for notification every time that the app starts. Per le app che vengono eseguite di frequente, oltre una volta al giorno, è possibile ignorare la registrazione per conservare la larghezza di banda qualora sia trascorso meno di un giorno dalla registrazione precedente.For apps that are run frequently, more than once a day, you can probably skip registration to preserve bandwidth if less than a day has passed since the previous registration.

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

    A questo punto, non dovrebbe essere presente altro codice nel metodo didRegisterForRemoteNotificationsWithDeviceToken.At this point, there should be no other code in the didRegisterForRemoteNotificationsWithDeviceToken method.

  10. I metodi seguenti devono essere già presenti in AppDelegate.m dopo aver completato l'esercitazione Introduzione ad hub di notifica .The following methods should already be present in AppDelegate.m from completing the Get started with Notification Hubs tutorial. In caso contrario, aggiungerli.If not, add them.

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

    This method handles notifications received when the app is running by displaying a simple UIAlert.This method handles notifications received when the app is running by displaying a simple UIAlert.

  11. In ViewController.m aggiungere un'istruzione import per AppDelegate.h e copiare il codice seguente nel metodo subscribe generato da XCode.In ViewController.m, add an import statement for AppDelegate.h and copy the following code into the XCode-generated subscribe method. Questo codice aggiorna la registrazione della notifica per usare i nuovi tag di categoria selezionati dall'utente nell'interfaccia utente.This code updates the notification registration to use the new category tags the user has chosen in the user interface.

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

    Questo metodo crea un oggetto NSMutableArray per le categorie e usa la classe Notifications per archiviare l'elenco nella risorsa di archiviazione locale e registrare i tag corrispondenti nell'hub di notifica.This method creates an NSMutableArray of categories and uses the Notifications class to store the list in the local storage and registers the corresponding tags with your notification hub. Se le categorie vengono modificate, la registrazione viene ricreata con le nuove categorie.When categories are changed, the registration is recreated with the new categories.

  12. In ViewController.m aggiungere il codice seguente nel metodo viewDidLoad per impostare l'interfaccia utente in base alle categorie salvate in precedenza.In ViewController.m, add the following code in the viewDidLoad method to set the user interface based on the previously saved categories.

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

Ora l'app può archiviare un insieme di categorie nella risorsa di archiviazione locale del dispositivo utilizzata per la registrazione con l'hub di notifica ogni volta che l'app viene avviata.The app can now store a set of categories in the device local storage used to register with the notification hub whenever the app starts. L'utente può modificare la selezione di categorie al runtime e scegliere il metodo subscribe per aggiornare la registrazione per il dispositivo.The user can change the selection of categories at runtime and click the subscribe method to update the registration for the device. Successivamente, si aggiorna l'app per inviare le notifiche relative alle ultime notizie direttamente nell'app stessa.Next, you update the app to send the breaking news notifications directly in the app itself.

(facoltativo) Invio di notifiche con tag(optional) Send tagged notifications

Se non si ha accesso a Visual Studio, è possibile passare alla sezione successiva e inviare notifiche dall’app stessa.If you don't have access to Visual Studio, you can skip to the next section and send notifications from the app itself. È anche possibile inviare la notifica del modello appropriata dal portale di Azure usando la scheda debug per l'hub di notifica.You can also send the proper template notification from the Azure portal using the debug tab for your notification hub.

In questa sezione si invieranno notizie aggiornate come notifiche modello con tag da un'app console .NET.In this section, you send breaking news as tagged template notifications from a .NET console app.

  1. In Visual Studio creare una nuova applicazione console in Visual C#:In Visual Studio, create a new Visual C# console application:

    1. Nel menu selezionare File > Nuovo > Progetto.On the menu, select File > New > Project.
    2. In Crea un nuovo progetto selezionare App console (.NET Framework) per C# nell'elenco di modelli e scegliere Avanti.In Create a new project, select Console App (.NET Framework) for C# in the list of templates, and select Next.
    3. Immettere un nome per l'app.Enter a name for the app.
    4. Per Soluzione scegliere Aggiungi a soluzione e selezionare Crea per creare il progetto.For Solution, choose Add to solution, and select Create to create the project.
  2. Scegliere Strumenti, > Gestione pacchetti NuGet > Console di Gestione pacchetti e quindi eseguire il comando seguente nella finestra della console:Select Tools > NuGet Package Manager > Package Manager Console and then, in the console window, run the following command:

    Install-Package Microsoft.Azure.NotificationHubs
    

    Questa azione aggiunge un riferimento ad Azure Notification Hubs SDK usando il pacchetto Microsoft.Azure.NotificationHubs.This action adds a reference to the Azure Notification Hubs SDK by using the Microsoft.Azure.NotificationHubs package.

  3. Aprire il file Program.cs e aggiungere l'istruzione using seguente:Open the Program.cs file, and add the following using statement:

    using Microsoft.Azure.NotificationHubs;
    
  4. Nella classe Program aggiungere il metodo seguente oppure sostituirlo se esiste già:In the Program class, add the following method, or replace it if it already exists:

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

    Questo codice invia una notifica modello per ognuno dei sei tag nella matrice di stringhe.This code sends a template notification for each of the six tags in the string array. L'uso di tag garantisce che i dispositivi ricevano le notifiche solo per le categorie registrate.The use of tags ensures that devices receive notifications only for the registered categories.

  5. Nel codice precedente sostituire i segnaposto <hub name> e <connection string with full access> con il nome dell'hub di notifica e la stringa di connessione per DefaultFullSharedAccessSignature dal dashboard dell'hub di notifica.In the preceding code, replace the <hub name> and <connection string with full access> placeholders with your notification hub name and the connection string for DefaultFullSharedAccessSignature from the dashboard of your notification hub.

  6. Nel metodo Main() aggiungere le righe seguenti:In the Main() method, add the following lines:

     SendTemplateNotificationAsync();
     Console.ReadLine();
    
  7. Creare l'app console.Build the console app.

(facoltativo) Inviare notifiche dal dispositivo(optional) Send notifications from the device

In genere le notifiche vengono inviate da un servizio di back-end ma per questa esercitazione è possibile inviare notifiche relative alle ultime notizie direttamente dall'applicazione.Normally notifications would be sent by a backend service but, you can send breaking news notifications directly from the app. A tale scopo, è necessario aggiornare il metodo SendNotificationRESTAPI definito nell'esercitazione Introduzione ad hub di notifica .To do so, you update the SendNotificationRESTAPI method that you defined in the Get started with Notification Hubs tutorial.

  1. In ViewController.m aggiornare il metodo SendNotificationRESTAPI come segue in modo che accetti un parametro per il tag di categoria e invii la notifica modello appropriata.In ViewController.m, update the SendNotificationRESTAPI method as follows so that it accepts a parameter for the category tag and sends the proper template notification.

    - (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];
    }
    
  2. In ViewController.m aggiornare l'azione Send Notification, come illustrato nel codice seguente.In ViewController.m, update the Send Notification action as shown in the code that follows. In tal modo si inviano notifiche a più piattaforme usando singolarmente ogni tag.So that it sends the notifications using each tag individually and sends to multiple platforms.

    - (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];
        }
    }
    
  3. Ricompilare il progetto e assicurarsi che non siano presenti errori di compilazione.Rebuild your project and make sure you have no build errors.

Esecuzione dell'app e generazione di notificheRun the app and generate notifications

  1. Premere il pulsante Esegui per compilare il progetto e avviare l'app.Press the Run button to build the project and start the app. Selezionare alcune opzioni di notizie per cui eseguire la sottoscrizione e premere il pulsante Subscribe .Select some breaking news options to subscribe to and then press the Subscribe button. Verrà visualizzata una finestra di dialogo che indica che è staa effettuata la sottoscrizione alle notifiche.You should see a dialog indicating the notifications have been subscribed to.

    Esempio notifica in iOS

    Quando si fa clic su Subscribe, l'app converte le categorie selezionate in tag e richiede una nuova registrazione del dispositivo per i tag selezionati dall'hub di notifica.When you choose Subscribe, the app converts the selected categories into tags and requests a new device registration for the selected tags from the notification hub.

  2. Immettere un messaggio da inviare come ultime notizie, quindi premere il pulsante Send Notification (Invia notifica).Enter a message to be sent as breaking news then press the Send Notification button. In alternativa, eseguire l'app console .NET per generare le notifiche.Alternatively, run the .NET console app to generate notifications.

    Modificare le preferenze per le notifiche in iOS

  3. Ogni dispositivo iscritto alle notizie riceverà le notifiche relative alle ultime notizie appena inviate.Each device subscribed to breaking news receives the breaking news notifications you just sent.

Passaggi successiviNext steps

In questa esercitazione sono state inviate notifiche di trasmissione ai dispositivi iOS specifici che hanno effettuato la registrazione alle categorie.In this tutorial, you sent broadcast notifications to specific iOS devices that have registered for the categories. Per informazioni sulle procedure per eseguire il push di notifiche localizzate passare all'esercitazione seguente:To learn how to push localized notifications, advance to the following tutorial: