Introduzione ad Hub di notifica con Xamarin per AndroidGet started with Notification Hubs with Xamarin for Android

PanoramicaOverview

In questa esercitazione viene illustrato come usare Hub di notifica di Azure per inviare notifiche push a un'applicazione di Xamarin.Android.This tutorial shows you how to use Azure Notification Hubs to send push notifications to a Xamarin.Android application. Verrà creata un'app per Xamarin.Android vuota che riceve notifiche push tramite il servizio Google Cloud Messaging (GCM).You'll create a blank Xamarin.Android app that receives push notifications by using Google Cloud Messaging (GCM). Al termine, sarà possibile usare l’hub di notifica per trasmettere le notifiche push a tutti i dispositivi che eseguono l'app.When you're finished, you'll be able to use your notification hub to broadcast push notifications to all the devices running your app. Il codice compilato è disponibile nell'esempio di app NotificationHubs.The finished code is available in the NotificationHubs app sample.

Questa esercitazione illustra uno scenario di trasmissione semplice tramite hub di notifica.This tutorial demonstrates the simple broadcast scenario in using Notification Hubs.

Prima di iniziareBefore you begin

Obiettivo di questo articolo è consentire di iniziare a usare Hub di notifica di Azure il prima possibile.The goal of this article is to help you get started using Azure Notification Hubs as quickly as possible. L'articolo presenta uno scenario di trasmissione molto semplice che illustra i concetti di base di Hub di notifica.The article presents a very simple broadcast scenario that focuses on the basic concepts of Notification Hubs.

Se si ha già familiarità con Hub di notifica, è possibile selezionare un altro argomento nel riquadro di spostamento a sinistra o passare agli articoli pertinenti nella sezione "Passaggi successivi".If you are already familiar with Notification Hubs, you might want to select another topic from the left navigation or go to the relevant articles in the "Next steps" section.

I commenti e suggerimenti inviati verranno presi seriamente in considerazione.We take your feedback seriously. Se si riscontrano difficoltà nel completare questo argomento o si hanno suggerimenti per migliorarne il contenuto, è possibile lasciare un commento alla fine dell'articolo.If you have any difficulty completing this topic, or if you have recommendations for improving this content, we invite you to provide feedback at the end of the article.

Il codice completo per questa esercitazione è disponibile su GitHub qui.The completed code for this tutorial can be found on GitHub here.

PrerequisitiPrerequisites

Per completare questa esercitazione, è necessario disporre di:This tutorial requires the following:

Il completamento di questa esercitazione costituisce un prerequisito per tutte le altre esercitazioni di Hub di notifica relative ad app per Xamarin.Android.Completing this tutorial is a prerequisite for all other Notification Hubs tutorials for Xamarin.Android apps.

Importante

Per completare l'esercitazione, è necessario disporre di un account Azure attivo.To complete this tutorial, you must have an active Azure account. Se non si dispone di un account, è possibile creare un account di valutazione gratuita in pochi minuti.If you don't have an account, you can create a free trial account in just a couple of minutes. Per informazioni dettagliate, vedere la pagina relativa alla versione di valutazione gratuita di Azure.For details, see Azure Free Trial.

Abilitare Google Cloud MessagingEnable Google Cloud Messaging

  1. Passare a Google Cloud Consoleed eseguire l'accesso con le credenziali dell'account Google.Navigate to the Google Cloud Console, sign in with your Google account credentials.
  2. Fare clic su Crea progetto, digitare un nome di progetto e quindi fare clic su Crea.Click Create Project, type a project name, then click Create. Se necessario, eseguire la verifica SMS, quindi fare nuovamente clic su Crea .If requested, carry out the SMS Verification, and click Create again.

    Creare un nuovo progetto

    Digitare il nuovo nome del progetto e fare clic su Crea progetto.Type in your new Project name and click Create project.

  3. Fare clic sul pulsante Utilities and More (Utilità e altro) e quindi su Informazioni progetto.Click the Utilities and More button and then click Project Information. Prendere nota del valore di Project Number.Make a note of the Project Number. Sarà necessario impostare questo valore come variabile SenderId nell'app client.You will need to set this value as the SenderId variable in the client app.

    Utilità e altro ancora

  4. Nel dashboard del progetto fare clic su Google Cloud Messaging in Mobile APIs (API per dispositivi mobili), quindi nella pagina successiva fare clic su Enable API (Abilita API) e accettare le condizioni del servizio.In the project dashboard, under Mobile APIs, click Google Cloud Messaging, then on the next page click Enable API and accept the terms of service.

    Abilitare GCM

    Abilitare GCM

  5. Nel dashboard del progetto fare clic su Credenziali > Crea credenziale > Chiave API.In the project dashboard, Click Credentials > Create Credential > API Key.

  6. In Crea una nuova chiave fare clic su Chiave server, digitare un nome per la chiave e quindi fare clic su Crea.In Create a new key, click Server key, type a name for your key, then click Create.
  7. Prendere nota del valore di API KEY .Make a note of the API KEY value.

    Questo valore della chiave dell'API verrà usato successivamente per abilitare Azure per l'autenticazione con GCM e l'invio di notifiche push per conto dell'app.You will use this API key value to enable Azure to authenticate with GCM and send push notifications on behalf of your app.

Configurare l'hub di notificaConfigure your notification hub

  1. Accedere al portale di Azure.Sign in to the Azure portal.

  2. Selezionare Nuovo > Web e dispositivi mobili > Hub di notifica.Select New > Web + Mobile > Notification Hub.

    Portale di Azure: creare un hub di notifica

  3. Nella casella Hub di notifica digitare un nome univoco.In the Notification Hub box, type a unique name. Selezionare l'area, la sottoscrizione e il gruppo di risorse (se già disponibili).Select your Region, Subscription, and Resource Group (if you have one already).

    Se si ha già un spazio dei nomi del bus di servizio in cui si vuole creare l'hub, seguire questa procedura:If you already have a service bus namespace that you want to create the hub in, do the following:

    a.a. Nell'area Spazio dei nomi selezionare il collegamento Seleziona esistente.In the Namespace area, select the Select Existing link.

    b.b. Selezionare Crea.Select Create.

    Se non si ha già uno spazio dei nomi del bus di servizio, è possibile usare il nome predefinito, che viene creato in base al nome dell'hub (se lo spazio dei nomi è disponibile).If you don't already have a service bus namespace, you can use the default name, which is created based on the hub name (if the namespace name is available).

    Portale di Azure: impostare le proprietà dell'hub di notifica

    Dopo avere creato lo spazio dei nomi e l'hub di notifica, viene aperto il portale di Azure.After you've created the namespace and notification hub, the Azure portal opens.

    Portale di Azure: pagina del portale dell'hub di notifica

  4. Selezionare Impostazioni > Criteri di accesso.Select Settings > Access Policies. Prendere nota delle due stringhe di connessione disponibili.Note the two connection strings that are available to you. Saranno necessarie in un secondo momento per gestire le notifiche push.You will need them to handle push notifications later.

    Portale di Azure: stringhe di connessione dell'hub di notifica

  1. Scegliere la scheda Configure (Configura) nella parte superiore, immettere il valore di API Key (Chiave API) ottenuto nella sezione precedente e quindi selezionare su Save (Salva).Choose the Configure tab at the top, enter the API Key value you obtained in the previous section, and then select Save.

    

L'hub di notifica è ora configurato per l'uso con GCM e si dispone delle stringhe di connessione per registrare l'app in modo da ricevere e inviare le notifiche push.Your notification hub is now configured to work with GCM, and you have the connection strings to both register your app to receive notifications and to send push notifications.

Connettere l'app all'hub di notificaConnect your app to the notification hub

Creare prima di tutto un nuovo progetto.First, you create a new project.

  1. In Xamarin Studio scegliere New Solution (Nuova soluzione) > Android App (App Android) e quindi selezionare Next (Avanti).In Xamarin Studio, choose New Solution > Android App and then select Next.

  2. Compilare i campi App Name (Nome app) e Identifier (Identificatore).Enter your App Name and Identifier. Scegliere Target Plaforms (Piattaforme di destinazione) per selezionare la piattaforma da supportare e quindi fare clic su Next (Avanti) e su Create (Crea).Choose the Target Plaforms you want to support and then choose Next and Create.

    In questo modo viene creato un nuovo progetto Android.This creates a new Android project.

  3. Aprire le proprietà del progetto facendo clic con il pulsante destro del mouse sul nuovo progetto nella visualizzazione Solution e scegliendo Options.Open the project properties by right-clicking your new project in the Solution view and choosing Options. Selezionare la voce Android Application (Applicazione Android) nella sezione Build (Crea).Select the Android Application item in the Build section.

    Verificare che la prima lettera di Package name sia minuscola.Ensure that the first letter of your Package name is lowercase.

    Importante

    La prima lettera del nome del pacchetto deve essere minuscola.The first letter of the package name must be lowercase. In caso contrario, verranno visualizzati errori del manifesto dell'applicazione al momento della registrazione di BroadcastReceiver e IntentFilter per le notifiche push più avanti.Otherwise, you will receive application manifest errors when you register your BroadcastReceiver and IntentFilter for push notifications below.

  4. Impostare facoltativamente Minimum Android version su un altro livello API.Optionally, set the Minimum Android version to another API Level.
  5. Facoltativamente, impostare Target Android version sulla versione dell'API di destinazione (deve essere almeno API livello 8 o superiore).Optionally, set the Target Android version to the another API version that you want to target (must be API level 8 or higher).
  6. Scegliere OK e chiudere la finestra di dialogo delle opzioni del progetto.Choose OK and close the Project Options dialog.

Aggiungere i componenti necessari al progettoAdd the required components to your project

Il client Google Cloud Messaging disponibile in Xamarin Component Store semplifica il processo di supporto delle notifiche push in Xamarin.Android.The Google Cloud Messaging Client available on the Xamarin Component Store simplifies the process of supporting push notifications in Xamarin.Android.

  1. Fare clic con il pulsante destro del mouse sulla cartella Components nell'app Xamarin.Android e scegliere Get More Components.Right-click the Components folder in Xamarin.Android app and choose Get More Components.
  2. Cercare il componente Messaggistica di Azure e aggiungerlo al progetto.Search for the Azure Messaging component and add it to the project.
  3. Cercare il componente Client Google Cloud Messaging e aggiungerlo al progetto.Search for the Google Cloud Messaging Client component and add it to the project.

Configurare Hub di notifica nel progettoSet up notification hubs in your project

  1. Raccogliere le informazioni seguenti per l'app Android e l'hub di notifica:Gather the following information for your Android app and notification hub:

    • GoogleProjectNumber: ottenere il valore Project Number (Numero progetto) dalla panoramica dell'app nel portale di sviluppo di Google.GoogleProjectNumber: Get this Project Number value from the overview of your app on the Google Developer Portal. Prendere nota di questo valore in precedenza, durante la creazione dell'app nel portale.You made a note of this value earlier when you created the app on the portal.
    • Stringa di connessione Listen: nel dashboard del portale di Azure classico scegliere Visualizza stringhe di connessione.Listen connection string: On the dashboard in the [Azure Classic Portal], choose View connection strings. Copiare la stringa di connessione DefaultListenSharedAccessSignature per questo valore.Copy the DefaultListenSharedAccessSignature connection string for this value.
    • Hub name: si tratta del nome dell'hub del portale di Azure classico.Hub name: This is the name of your hub from the [Azure Classic Portal]. Ad esempio, mynotificationhub2.For example, mynotificationhub2.
  2. Creare una classe Constants.cs per il progetto Xamarin e definire i valori costanti seguenti nella classe.Create a Constants.cs class for your Xamarin project and define the following constant values in the class. Sostituire i segnaposto con i valori.Replace the placeholders with your values.

     public static class Constants
     {
    
        public const string SenderID = "<GoogleProjectNumber>"; // Google API Project Number
        public const string ListenConnectionString = "<Listen connection string>";
        public const string NotificationHubName = "<hub name>";
     }
    
  3. Aggiungere le istruzioni using seguenti a MainActivity.cs:Add the following using statements to MainActivity.cs:

     using Android.Util;
     using Gcm.Client;
    
  4. Aggiungere una variabile di istanza alla classe MainActivity che verrà usata per visualizzare una finestra di dialogo di avviso quando l'app è in esecuzione:Add an instance variable to the MainActivity class that will be used to show an alert dialog when the app is running:

     public static MainActivity instance;
    
  5. Creare il metodo seguente nella classe MainActivity :Create the following method in the MainActivity class:

     private void RegisterWithGCM()
     {
         // Check to ensure everything's set up right
         GcmClient.CheckDevice(this);
         GcmClient.CheckManifest(this);
    
         // Register for push notifications
         Log.Info("MainActivity", "Registering...");
         GcmClient.Register(this, Constants.SenderID);
     }
    
  6. Nel metodo OnCreate di MainActivity.cs inizializzare la variabile instance e aggiungere una chiamata a RegisterWithGCM:In the OnCreate method of MainActivity.cs, initialize the instance variable and add a call to RegisterWithGCM:

     protected override void OnCreate (Bundle bundle)
     {
         instance = this;
    
         base.OnCreate (bundle);
    
         // Set your view from the "main" layout resource
         SetContentView (Resource.Layout.Main);
    
         // Get your button from the layout resource,
         // and attach an event to it
         Button button = FindViewById<Button> (Resource.Id.myButton);
    
         RegisterWithGCM();
     }
    
  7. Creare una nuova classe MyBroadcastReceiver.Create a new class, MyBroadcastReceiver.

    Nota

    Di seguito è illustrata in dettaglio la creazione da zero di una classe BroadcastReceiver .We will walk through creating a BroadcastReceiver class from scratch below. Esiste tuttavia un'alternativa più rapida alla creazione manuale di MyBroadcastReceiver.cs, che consiste nel fare riferimento al file GcmService.cs disponibile nel progetto Xamarin.Android di esempio incluso con gli esempi di NotificationHubs.However, a quick alternative to manually creating MyBroadcastReceiver.cs is to refer to the GcmService.cs file found in the sample Xamarin.Android project included with the NotificationHubs samples. Anche duplicare il file GcmService.cs e modificare i nomi delle classi può essere un ottimo punto di partenza.Duplicating GcmService.cs and changing class names can be a great place to start as well.

  8. Aggiungere le istruzioni using seguenti a MyBroadcastReceiver.cs , facendo riferimento al componente e all'assembly aggiunti in precedenza:Add the following using statements to MyBroadcastReceiver.cs (referring to the component and assembly that you added earlier):

     using System.Collections.Generic;
     using System.Text;
     using Android.App;
     using Android.Content;
     using Android.Util;
     using Gcm.Client;
     using WindowsAzure.Messaging;
    
  9. In MyBroadcastReceiver.cs aggiungere le richieste di autorizzazione seguenti tra le istruzioni using e la dichiarazione namespace:In MyBroadcastReceiver.cs, add the following permission requests between the using statements and the namespace declaration:

     [assembly: Permission(Name = "@PACKAGE_NAME@.permission.C2D_MESSAGE")]
     [assembly: UsesPermission(Name = "@PACKAGE_NAME@.permission.C2D_MESSAGE")]
     [assembly: UsesPermission(Name = "com.google.android.c2dm.permission.RECEIVE")]
    
     //GET_ACCOUNTS is needed only for Android versions 4.0.3 and below
     [assembly: UsesPermission(Name = "android.permission.GET_ACCOUNTS")]
     [assembly: UsesPermission(Name = "android.permission.INTERNET")]
     [assembly: UsesPermission(Name = "android.permission.WAKE_LOCK")]
    
  10. In MyBroadcastReceiver.cs modificare la classe MyBroadcastReceiver in modo che corrisponda all'esempio seguente:In MyBroadcastReceiver.cs, change the MyBroadcastReceiver class to match the following:

    [BroadcastReceiver(Permission=Gcm.Client.Constants.PERMISSION_GCM_INTENTS)]
    [IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_MESSAGE },
        Categories = new string[] { "@PACKAGE_NAME@" })]
    [IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_REGISTRATION_CALLBACK },
        Categories = new string[] { "@PACKAGE_NAME@" })]
    [IntentFilter(new string[] { Gcm.Client.Constants.INTENT_FROM_GCM_LIBRARY_RETRY },
        Categories = new string[] { "@PACKAGE_NAME@" })]
    public class MyBroadcastReceiver : GcmBroadcastReceiverBase<PushHandlerService>
    {
        public static string[] SENDER_IDS = new string[] { Constants.SenderID };
    
        public const string TAG = "MyBroadcastReceiver-GCM";
    }
    
  11. Aggiungere un'altra classe in MyBroadcastReceiver.cs denominata PushHandlerService che deriva da GcmServiceBase.Add another class in MyBroadcastReceiver.cs named PushHandlerService, which derives from GcmServiceBase. Assicurarsi di applicare l'attributo Service alla classe:Make sure to apply the Service attribute to the class:

     [Service] // Must use the service tag
     public class PushHandlerService : GcmServiceBase
     {
         public static string RegistrationID { get; private set; }
         private NotificationHub Hub { get; set; }
    
         public PushHandlerService() : base(Constants.SenderID)
            {
             Log.Info(MyBroadcastReceiver.TAG, "PushHandlerService() constructor");
         }
     }
    
  12. GcmServiceBase implementa i metodi OnRegistered(), OnUnRegistered(), OnMessage(), OnRecoverableError() e OnError().GcmServiceBase implements methods OnRegistered(), OnUnRegistered(), OnMessage(), OnRecoverableError(), and OnError(). La classe di implementazione PushHandlerService deve eseguire l'override di questi metodi, che si attiveranno in risposta all'interazione con l'hub di notifica.Our PushHandlerService implementation class must override these methods, and these methods will fire in response to interacting with the notification hub.
  13. Eseguire l'override del metodo OnRegistered() in PushHandlerService con il codice seguente:Override the OnRegistered() method in PushHandlerService by using the following code:

     protected override void OnRegistered(Context context, string registrationId)
     {
         Log.Verbose(MyBroadcastReceiver.TAG, "GCM Registered: " + registrationId);
         RegistrationID = registrationId;
    
         createNotification("PushHandlerService-GCM Registered...",
                             "The device has been Registered!");
    
         Hub = new NotificationHub(Constants.NotificationHubName, Constants.ListenConnectionString,
                                     context);
         try
         {
             Hub.UnregisterAll(registrationId);
         }
         catch (Exception ex)
         {
             Log.Error(MyBroadcastReceiver.TAG, ex.Message);
         }
    
         //var tags = new List<string>() { "falcons" }; // create tags if you want
         var tags = new List<string>() {};
    
         try
         {
             var hubRegistration = Hub.Register(registrationId, tags.ToArray());
         }
         catch (Exception ex)
         {
             Log.Error(MyBroadcastReceiver.TAG, ex.Message);
         }
     }
    

    Nota

    Nel codice OnRegistered() precedente notare la capacità di specificare tag per la registrazione a canali di messaggistica specifici.In the OnRegistered() code above, you should note the ability to specify tags to register for specific messaging channels.

  14. Eseguire l'override del metodo OnMessage in PushHandlerService con il codice seguente:Override the OnMessage method in PushHandlerService by using the following code:

    protected override void OnMessage(Context context, Intent intent)
    {
        Log.Info(MyBroadcastReceiver.TAG, "GCM Message Received!");
    
        var msg = new StringBuilder();
    
        if (intent != null && intent.Extras != null)
        {
            foreach (var key in intent.Extras.KeySet())
                msg.AppendLine(key + "=" + intent.Extras.Get(key).ToString());
        }
    
        string messageText = intent.Extras.GetString("message");
        if (!string.IsNullOrEmpty (messageText))
        {
            createNotification ("New hub message!", messageText);
        }
        else
        {
            createNotification ("Unknown message details", msg.ToString ());
        }
    }
    
  15. Aggiungere i metodi createNotification e dialogNotify seguenti a PushHandlerService per informare gli utenti quando viene ricevuta una notifica.Add the following createNotification and dialogNotify methods to PushHandlerService for notifying users when a notification is received.

    Nota

    La progettazione di notifiche in Android versione 5.0 e successive rappresenta un'importante variazione rispetto alle versioni precedenti.Notification design in Android version 5.0 and later represents a significant departure from that of previous versions. Se si testa in Android 5.0 o versioni successive, l'app deve essere in esecuzione per poter ricevere la notifica.If you test this on Android 5.0 or later, the app will need to be running to receive the notification. Per altre informazioni, vedere Notifiche di Android.For more information, see Android Notifications.

    void createNotification(string title, string desc)
    {
        //Create notification
        var notificationManager = GetSystemService(Context.NotificationService) as NotificationManager;
    
        //Create an intent to show UI
        var uiIntent = new Intent(this, typeof(MainActivity));
    
        //Create the notification
        var notification = new Notification(Android.Resource.Drawable.SymActionEmail, title);
    
        //Auto-cancel will remove the notification once the user touches it
        notification.Flags = NotificationFlags.AutoCancel;
    
        //Set the notification info
        //we use the pending intent, passing our ui intent over, which will get called
        //when the notification is tapped.
        notification.SetLatestEventInfo(this, title, desc, PendingIntent.GetActivity(this, 0, uiIntent, 0));
    
        //Show the notification
        notificationManager.Notify(1, notification);
        dialogNotify (title, desc);
    }
    
    protected void dialogNotify(String title, String message)
    {
    
        MainActivity.instance.RunOnUiThread(() => {
            AlertDialog.Builder dlg = new AlertDialog.Builder(MainActivity.instance);
            AlertDialog alert = dlg.Create();
            alert.SetTitle(title);
            alert.SetButton("Ok", delegate {
                alert.Dismiss();
            });
            alert.SetMessage(message);
            alert.Show();
        });
    }
    
  16. Eseguire l'override dei membri astratti OnUnRegistered(), OnRecoverableError() e OnError() per consentire la compilazione del codice:Override abstract members OnUnRegistered(), OnRecoverableError(), and OnError() so that your code compiles:

    protected override void OnUnRegistered(Context context, string registrationId)
    {
        Log.Verbose(MyBroadcastReceiver.TAG, "GCM Unregistered: " + registrationId);
    
        createNotification("GCM Unregistered...", "The device has been unregistered!");
    }
    
    protected override bool OnRecoverableError(Context context, string errorId)
    {
        Log.Warn(MyBroadcastReceiver.TAG, "Recoverable Error: " + errorId);
    
        return base.OnRecoverableError (context, errorId);
    }
    
    protected override void OnError(Context context, string errorId)
    {
        Log.Error(MyBroadcastReceiver.TAG, "GCM Error: " + errorId);
    }
    

Eseguire l'app nell'emulatoreRun your app in the emulator

Se si esegue l'app nell'emulatore, assicurarsi di usare un emulatore Android Virtual Device (AVD) con il supporto per Google APIs.If you run this app in the emulator, make sure that you use an Android Virtual Device (AVD) that supports Google APIs.

Importante

Per ricevere notifiche push, è necessario impostare un account Google in Android Virtual Device.In order to receive push notifications, you must set up a Google account on your Android Virtual Device. Nell'emulatore passare a Settings (Impostazioni) e scegliere Add Account (Aggiungi account). Assicurarsi inoltre che l'emulatore sia connesso a Internet.(In the emulator, navigate to Settings and choose Add Account.) Also, make sure that the emulator is connected to the Internet.

Nota

La progettazione di notifiche in Android versione 5.0 e successive rappresenta un'importante variazione rispetto alle versioni precedenti.Notification design in Android version 5.0 and later represents a significant departure from that of previous versions. Per altre informazioni, vedere Notifiche di Android.For more information, see Android Notifications.

  1. In Tools (Strumenti) scegliere Open Android Emulator Manager (Apri Gestione emulatori Android), selezionare il dispositivo e quindi scegliere Edit (Modifica).From Tools, choose Open Android Emulator Manager, select your device, and then choose Edit.

  2. Selezionare Google APIs (API Google) in Target (Destinazione) e quindi scegliere OK.Select Google APIs in Target, and then choose OK.

  3. Scegliere Run (Esegui) sulla barra degli strumenti nella parte superiore della schermata e selezionare l'app.On the top toolbar, choose Run, and then select your app. In questo modo l'emulatore viene avviato e l'app eseguita.This starts the emulator and runs the app.

    L'app recupera la proprietà registrationId da GCM ed esegue la registrazione con l'hub di notifica.The app retrieves the registrationId from GCM and registers with the notification hub.

Inviare notifiche dal back-endSend notifications from your backend

È possibile testare la ricezione delle notifiche nell'app inviando notifiche nel portale di Azure classico tramite la scheda Debug nell'hub di notifica, come illustrato nella schermata seguente.You can test receiving notifications in your app by sending notifications in the [Azure Classic Portal] via the debug tab on the notification hub, as shown in the screen below.

Le notifiche push vengono in genere inviate in un servizio back-end come Servizi mobili o ASP.NET usando una libreria compatibile.Push notifications are normally sent in a backend service like Mobile Services or ASP.NET through a compatible library. È anche possibile utilizzare l'API REST direttamente per inviare messaggi di notifica se una libreria non è disponibile per il back-end.You can also use the REST API directly to send notification messages if a library is not available for your backend.

Di seguito è riportato un elenco di altre esercitazioni, che è possibile esaminare per l'invio di notifiche:Here is a list of some other tutorials that you may want to review for sending notifications:

Nelle sezioni secondarie successive di questa esercitazione vengono inviate notifiche con un'app console .NET e con un servizio mobile tramite uno script node.In the next subsections of the tutorial, you send notifications by using a .NET console app, and by using a mobile service through a node script.

(Facoltativo) Inviare notifiche tramite un'app .NET(Optional) Send notifications by using a .NET app

In questa sezione si invieranno notifiche con un'app console .NET.In this section, we will send notifications by using a .NET console app

  1. Creare una nuova applicazione console in Visual C#:Create a new Visual C# console application:

  2. In Visual Studio scegliere Strumenti > Gestione pacchetti NuGet e quindi selezionare Console di Gestione pacchetti.In Visual Studio, choose Tools > NuGet Package Manager, and then select Package Manager Console.

    In questo modo viene visualizzata la console di Gestione pacchetti in Visual Studio.This displays the Package Manager Console in Visual Studio.

  3. Nella finestra Console di Gestione pacchetti impostare Progetto predefinito sul nuovo progetto di applicazione console, quindi eseguire il comando seguente nella finestra della console:In the Package Manager Console window, set the Default project to your new console application project, and then in the console window, execute the following command:

     Install-Package Microsoft.Azure.NotificationHubs
    

    Verrà aggiunto un riferimento all’SDK dell’Hub di notifica di Azure mediante il pacchetto NuGet Microsoft.Azure.NotificationHubs.This adds a reference to the Azure Notification Hubs SDK using the Microsoft.Azure.Notification Hubs NuGet package.

  4. 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;
    
  5. Nella classe Program aggiungere il metodo seguente.In your Program class, add the following method. Aggiornare il testo segnaposto con la stringa di connessione DefaultFullSharedAccessSignature e il nome dell'hub dal portale di Azure classico.Update the placeholder text with your DefaultFullSharedAccessSignature connection string and hub name from the [Azure Classic Portal].

     private static async void SendNotificationAsync()
     {
         NotificationHubClient hub = NotificationHubClient.CreateClientFromConnectionString("<connection string with full access>", "<hub name>");
         await hub.SendGcmNativeNotificationAsync("{ \"data\" : {\"message\":\"Hello from Azure!\"}}");
     }
    
  6. Aggiungere le righe seguenti nel metodo Main :Add the following lines in your Main method:

      SendNotificationAsync();
      Console.ReadLine();
    
  7. Premere F5 per eseguire l'app.Press the F5 key to run the app. Si dovrebbe ricevere una notifica nell’app.You should receive a notification in the app.

(Facoltativo) Inviare notifiche tramite un servizio mobile(Optional) Send notifications by using a mobile service

  1. Guardare Introduzione a Servizi mobili.Follow [Get started with Mobile Services].
  2. Accedere al portale di Azure classicoe selezionare il servizio mobile.Sign in to the [Azure Classic Portal], and select your mobile service.
  3. Selezionare la scheda Utilità di pianificazione in alto.Select the Scheduler tab on the top.

  4. Creare un nuovo processo pianificato, immettere un nome, quindi scegliere On demand.Create a new scheduled job, insert a name, and select On demand.

  5. Al termine della creazione del processo, selezionare il relativo nome.When the job is created, select the job name. Scegliere la scheda Script nella barra superiore.Then choose the Script tab on the top bar.
  6. Inserire lo script seguente all'interno della funzione dell'utilità di pianificazione.Insert the following script inside your scheduler function. Assicurarsi di sostituire i segnaposto con il nome dell'hub di notifica e la stringa di connessione associata a DefaultFullSharedAccessSignature ottenuti nel passaggio precedente.Make sure to replace the placeholders with your notification hub name and the connection string for DefaultFullSharedAccessSignature that you obtained earlier. Scegliere Salva.Choose Save.

     var azure = require('azure');
     var notificationHubService = azure.createNotificationHubService('<hub name>', '<connection string>');
     notificationHubService.gcm.send(null,'{"data":{"message" : "Hello from Mobile Services!"}}',
       function (error)
       {
         if (!error) {
            console.warn("Notification successful");
         }
         else
         {
           console.warn("Notification failed" + error);
         }
       }
     );
    
  7. Scegliere Esegui una volta sulla barra inferiore.Choose Run Once on the bottom bar. Si dovrebbe ricevere una notifica di tipo avviso popup.You should receive a toast notification.

Passaggi successiviNext steps

In questo semplice esempio le notifiche sono state trasmesse a tutti i dispositivi Android.In this simple example, you broadcasted notifications to all your Android devices. Per rivolgersi a utenti specifici, fare riferimento all'esercitazione Usare Hub di notifica per inviare notifiche push agli utenti.In order to target specific users, refer to the tutorial [Use Notification Hubs to push notifications to users]. Se si desidera segmentare gli utenti per gruppi di interesse, consultare Uso di Hub di notifica per inviare le ultime notizie.If you want to segment your users by interest groups, you can read [Use Notification Hubs to send breaking news]. Per altre informazioni sull'uso di Hub di notifica, vedere Panoramica dell'Hub di notifica e Notification Hubs How-To for Android..Learn more about how to use Notification Hubs in [Notification Hubs Guidance] and in the [Notification Hubs How-To for Android].