Aggiungere notifiche push all'app Xamarin.AndroidAdd push notifications to your Xamarin.Android app

PanoramicaOverview

In questa esercitazione vengono aggiunte notifiche push al progetto avvio rapido di Xamarin.Android, in modo che una notifica push venga inviata al dispositivo a ogni inserimento di record.In this tutorial, you add push notifications to the Xamarin.Android quickstart project so that a push notification is sent to the device every time a record is inserted.

Se non si usa il progetto server di avvio rapido scaricato, sarà necessario aggiungere il pacchetto di estensione di notifica push.If you do not use the downloaded quickstart server project, you will need the push notification extension package. Per altre informazioni, vedere Usare l'SDK del server back-end .NET per App per dispositivi mobili di Azure.For more information, see the Work with the .NET backend server SDK for Azure Mobile Apps guide.

prerequisitiPrerequisites

Per completare questa esercitazione, è necessario definire l'impostazione seguente:This tutorial requires the setup:

Configurare un hub di notificaConfigure a Notification Hub

Poiché le funzioni delle app per dispositivi mobili del Servizio app di Azure usano Hub di notifica di Azure per inviare push, si dovrà configurare un hub di notifica per l'app per dispositivi mobili.The Mobile Apps feature of Azure App Service uses Azure Notification Hubs to send pushes, so you will be configuring a notification hub for your mobile app.

  1. Nel portale di Azure passare a Servizi app e quindi selezionare il back-end dell'app.In the Azure portal, go to App Services, and then select your app back end. In Impostazioni selezionare Push.Under Settings, select Push.
  2. Per aggiungere una risorsa hub di notifica all'app selezionare Connetti.To add a notification hub resource to the app, select Connect. È possibile creare un hub o connettersi a uno esistente.You can either create a hub or connect to an existing one.

    Configurare un hub

A questo punto un hub di notifica è stato connesso al progetto di back-end dell'app per dispositivi mobili.Now you have connected a notification hub to your Mobile Apps back-end project. In seguito si configurerà questo hub di notifica per la connessione a un sistema PNS (Platform Notification System) per eseguire il push ai dispositivi.Later you configure this notification hub to connect to a platform notification system (PNS) to push to devices.

Abilitare Firebase Cloud MessagingEnable Firebase Cloud Messaging

  1. Accedere alla console di Firebase.Sign in to the Firebase console. Creare un nuovo progetto Firebase se non è già disponibile.Create a new Firebase project if you don't already have one.
  2. Dopo aver creato il progetto, selezionare Add Firebase to your Android app (Aggiungi Firebase all'app Android).After you create your project, select Add Firebase to your Android app. Seguire quindi le istruzioni visualizzate.Then follow the instructions that are provided. Scaricare il file google-services.json.Download google-services.json file.

    Aggiungere Firebase all'app Android

  3. Nella console di Firebase selezionare il file COG per il progetto.In the Firebase console, select the cog for your project. Selezionare quindi Project Settings (Impostazioni progetto).Then select Project Settings.

    Selezionare Project Settings (Impostazioni progetto)

  4. Selezionare la scheda General (Generale) nelle impostazioni del progetto.Select the General tab in your project settings. Scaricare quindi il file google-services.json che contiene la chiave API del server e l'ID client.Then download the google-services.json file that contains the Server API key and Client ID.
  5. Selezionare la scheda Cloud Messaging nelle impostazioni del progetto e quindi copiare il valore di Legacy server key (Chiave server legacy).Select the Cloud Messaging tab in your project settings, and then copy the value of the Legacy server key. Questo valore verrà usato per configurare i criteri di accesso all'hub di notifica.You use this value to configure the notification hub access policy.

Configurare Azure per l'invio di richieste pushConfigure Azure to send push requests

  1. Nel Portale di Azure fare clic su Browse All (Esplora tutto) > Servizi app e quindi scegliere il back-end dell'app per dispositivi mobili.In the Azure portal, click Browse All > App Services, and then click your Mobile Apps back end. In Impostazioni fare clic su App Service Push (Push servizio app), quindi fare clic sul nome dell'hub di notifica.Under Settings, click App Service Push, and then click your notification hub name.
  2. Passare a Google (GCM), immettere il valore Chiave server ottenuto da Firebase nella procedura precedente, quindi fare clic su Salva.Go to Google (GCM), enter the Server Key value that you obtained from Firebase in the previous procedure, and then click Save.

    Impostare la chiave API di GCM nel portale

Il back-end dell'app per dispositivi mobili è ora configurato per l'uso di Firebase Cloud Messaging.The Mobile Apps back end is now configured to use Firebase Cloud Messaging. Questo consente di inviare notifiche push all'app in esecuzione su un dispositivo Android usando l'hub di notifica.This enables you to send push notifications to your app running on an Android device, by using the notification hub.

Aggiornare il progetto server per l'invio di notifiche pushUpdate the server project to send push notifications

In questa sezione viene aggiornato il codice nel progetto di back-end dell'app per dispositivi mobili esistente per inviare una notifica push ogni volta che viene aggiunto un nuovo elemento.In this section, you update code in your existing Mobile Apps back-end project to send a push notification every time a new item is added. Questo processo si basa sulla funzionalità dei modelli di Hub di notifica di Azure, che abilita i push multipiattaforma.This process is powered by the template feature of Azure Notification Hubs, which enables cross-platform pushes. I diversi client vengono registrati per le notifiche push usando i modelli e un unico push universale può raggiungere tutte le piattaforme client.The various clients are registered for push notifications using templates, and a single universal push can get to all client platforms.

Scegliere una delle seguenti procedure che corrisponde al tipo di progetto di back-end—, che sia back-end .NET o back-end Node.js.Choose one of the following procedures that matches your back-end project type—either .NET back end or Node.js back end.

Progetto di back-end .NET.NET back-end project

  1. In Visual Studio fare clic con il pulsante destro del mouse sul progetto server.In Visual Studio, right-click the server project. Scegliere quindi Gestisci pacchetti NuGet.Then select Manage NuGet Packages. Cercare Microsoft.Azure.NotificationHubs e quindi selezionare Installa.Search for Microsoft.Azure.NotificationHubs, and then select Install. Questo processo installa la libreria Hub di notifica per l'invio di notifiche dal back-end.This process installs the Notification Hubs library for sending notifications from the back end.
  2. Nel progetto server aprire Controller > TodoItemController.cs.In the server project, open Controllers > TodoItemController.cs. Aggiungere quindi le istruzioni using seguenti:Then add the following using statements:

     using System.Collections.Generic;
     using Microsoft.Azure.NotificationHubs;
     using Microsoft.Azure.Mobile.Server.Config;
    
  3. Nel metodo PostTodoItem aggiungere il codice seguente dopo la chiamata a InsertAsync:In the PostTodoItem method, add the following code after the call to InsertAsync:

     // Get the settings for the server project.
     HttpConfiguration config = this.Configuration;
     MobileAppSettingsDictionary settings =
         this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();
    
     // Get the Notification Hubs credentials for the mobile app.
     string notificationHubName = settings.NotificationHubName;
     string notificationHubConnection = settings
         .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;
    
     // Create a new Notification Hub client.
     NotificationHubClient hub = NotificationHubClient
     .CreateClientFromConnectionString(notificationHubConnection, notificationHubName);
    
     // Send the message so that all template registrations that contain "messageParam"
     // receive the notifications. This includes APNS, GCM, WNS, and MPNS template registrations.
     Dictionary<string,string> templateParams = new Dictionary<string,string>();
     templateParams["messageParam"] = item.Text + " was added to the list.";
    
     try
     {
         // Send the push notification and log the results.
         var result = await hub.SendTemplateNotificationAsync(templateParams);
    
         // Write the success result to the logs.
         config.Services.GetTraceWriter().Info(result.State.ToString());
     }
     catch (System.Exception ex)
     {
         // Write the failure result to the logs.
         config.Services.GetTraceWriter()
             .Error(ex.Message, null, "Push.SendAsync Error");
     }
    

    Questo processo invia una notifica modello contenente item.Text quando viene inserito un nuovo elemento.This process sends a template notification that contains the item.Text when a new item is inserted.

  4. Pubblicare di nuovo il progetto server.Republish the server project.

Progetto di back-end Node.jsNode.js back-end project

  1. Se ancora non è stato fatto, scaricare il progetto di back-end di avvio rapido oppure usare l'editor online del Portale di Azure.If you haven't already done so, download the quickstart back-end project, or else use the online editor in the Azure portal.
  2. Sostituire il codice esistente in todoitem.js con il codice seguente:Replace the existing code in todoitem.js with the following code:

     var azureMobileApps = require('azure-mobile-apps'),
     promises = require('azure-mobile-apps/src/utilities/promises'),
     logger = require('azure-mobile-apps/src/logger');
    
     var table = azureMobileApps.table();
    
     table.insert(function (context) {
     // For more information about the Notification Hubs JavaScript SDK,
     // see http://aka.ms/nodejshubs.
     logger.info('Running TodoItem.insert');
    
     // Define the template payload.
     var payload = '{"messageParam": "' + context.item.text + '" }';  
    
     // Execute the insert. The insert returns the results as a promise.
     // Do the push as a post-execute action within the promise flow.
     return context.execute()
         .then(function (results) {
             // Only do the push if configured.
             if (context.push) {
                 // Send a template notification.
                 context.push.send(null, payload, function (error) {
                     if (error) {
                         logger.error('Error while sending push notification: ', error);
                     } else {
                         logger.info('Push notification sent successfully!');
                     }
                 });
             }
             // Don't forget to return the results from the context.execute().
             return results;
         })
         .catch(function (error) {
             logger.error('Error while running context.execute: ', error);
         });
     });
    
     module.exports = table;  
    

    Questo processo invia una notifica modello contenente item.text quando viene inserito un nuovo elemento.This process sends a template notification that contains the item.text when a new item is inserted.

  3. In caso di modifica del file nel computer locale, ripubblicare il progetto server.When you edit the file on your local computer, republish the server project.

Configurare il progetto client per le notifiche pushConfigure the client project for push notifications

  1. Nella visualizzazione della soluzione (o Esplora soluzioni in Visual Studio) fare clic con il pulsante destro del mouse sulla cartella Componenti, scegliere Ottieni altri componenti, cercare il componente Google Cloud Messaging Client e aggiungerlo al progetto.In the Solution view (or Solution Explorer in Visual Studio), right-click the Components folder, click Get More Components..., search for the Google Cloud Messaging Client component and add it to the project.
  2. Aprire il nuovo file di progetto ToDoActivity.cs e aggiungere l'istruzione using seguente alla classe:Open the ToDoActivity.cs project file and add the following using statement to the class:

     using Gcm.Client;
    
  3. Nella classe ToDoActivity aggiungere il nuovo codice seguente:In the ToDoActivity class, add the following new code:

     // Create a new instance field for this activity.
     static ToDoActivity instance = new ToDoActivity();
    
     // Return the current activity instance.
     public static ToDoActivity CurrentActivity
     {
         get
         {
             return instance;
         }
     }
     // Return the Mobile Services client.
     public MobileServiceClient CurrentClient
     {
         get
         {
             return client;
         }
     }
    

    Questa operazione consente di accedere all'istanza del client mobile dal processo del servizio del gestore push.This enables you to access the mobile client instance from the push handler service process.

  4. Aggiungere il codice seguente al metodo OnCreate, dopo la creazione di MobileServiceClient:Add the following code to the OnCreate method, after the MobileServiceClient is created:

    // Set the current instance of TodoActivity.
    instance = this;
    
    // Make sure the GCM client is set up correctly.
    GcmClient.CheckDevice(this);
    GcmClient.CheckManifest(this);
    
    // Register the app for push notifications.
    GcmClient.Register(this, ToDoBroadcastReceiver.senderIDs);
    

La classe ToDoActivity è ora pronta per l'aggiunta di notifiche push.Your ToDoActivity is now prepared for adding push notifications.

Aggiungere il codice delle notifiche push all'appAdd push notifications code to your app

  1. Creare una nuova classe nel progetto denominato ToDoBroadcastReceiver.Create a new class in the project called ToDoBroadcastReceiver.
  2. Aggiungere le istruzioni using seguenti alla classe ToDoBroadcastReceiver :Add the following using statements to ToDoBroadcastReceiver class:

     using Gcm.Client;
     using Microsoft.WindowsAzure.MobileServices;
     using Newtonsoft.Json.Linq;
    
  3. Aggiungere le richieste di autorizzazione seguenti tra le istruzioni using e la dichiarazione namespace: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 only needed 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")]
    
  4. Sostituire la definizione della classe ToDoBroadcastReceiver esistente con la seguente:Replace the existing ToDoBroadcastReceiver class definition with 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 ToDoBroadcastReceiver : GcmBroadcastReceiverBase<PushHandlerService>
     {
         // Set the Google app ID.
         public static string[] senderIDs = new string[] { "<PROJECT_NUMBER>" };
     }
    

    Nel codice precedente è necessario sostituire <PROJECT_NUMBER> con il numero di progetto assegnato da Google quando è stato effettuato il provisioning dell'app nel portale per sviluppatori di Google.In the above code, you must replace <PROJECT_NUMBER> with the project number assigned by Google when you provisioned your app in the Google developer portal.

  5. Nel file di progetto ToDoBroadcastReceiver.cs aggiungere il codice seguente che definisce la classe PushHandlerService :In the ToDoBroadcastReceiver.cs project file, add the following code that defines the PushHandlerService class:

     // The ServiceAttribute must be applied to the class.
     [Service] 
     public class PushHandlerService : GcmServiceBase
     {
         public static string RegistrationID { get; private set; }
    
         public PushHandlerService() : base(ToDoBroadcastReceiver.senderIDs) { }
     }
    

    Si noti che questa classe deriva da GcmServiceBase e che l'attributo Service deve essere applicato a questa classe.Note that this class derives from GcmServiceBase and that the Service attribute must be applied to this class.

    Nota

    La classe GcmServiceBase implementa i metodi OnRegistered(), OnUnRegistered(), OnMessage() e OnError().The GcmServiceBase class implements the OnRegistered(), OnUnRegistered(), OnMessage() and OnError() methods. È necessario eseguire l'override di questi metodi nella classe PushHandlerService .You must override these methods in the PushHandlerService class.

  6. Aggiungere il codice seguente alla classe PushHandlerService che sostituisce il gestore di eventi OnRegistered.Add the following code to the PushHandlerService class that overrides the OnRegistered event handler.

     protected override void OnRegistered(Context context, string registrationId)
     {
         System.Diagnostics.Debug.WriteLine("The device has been registered with GCM.", "Success!");
    
         // Get the MobileServiceClient from the current activity instance.
         MobileServiceClient client = ToDoActivity.CurrentActivity.CurrentClient;
         var push = client.GetPush();
    
         // Define a message body for GCM.
         const string templateBodyGCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";
    
         // Define the template registration as JSON.
         JObject templates = new JObject();
         templates["genericMessage"] = new JObject
         {
           {"body", templateBodyGCM }
         };
    
         try
         {
             // Make sure we run the registration on the same thread as the activity, 
             // to avoid threading errors.
             ToDoActivity.CurrentActivity.RunOnUiThread(
    
                 // Register the template with Notification Hubs.
                 async () => await push.RegisterAsync(registrationId, templates));
    
             System.Diagnostics.Debug.WriteLine(
                 string.Format("Push Installation Id", push.InstallationId.ToString()));
         }
         catch (Exception ex)
         {
             System.Diagnostics.Debug.WriteLine(
                 string.Format("Error with Azure push registration: {0}", ex.Message));
         }
     }
    

    Questo metodo usa l'ID di registrazione GCM restituito per la registrazione con Azure per l'invio di notifiche push.This method uses the returned GCM registration ID to register with Azure for push notifications. I tag possono essere aggiunti solo per la registrazione dopo averla creato.Tags can only be added to the registration after it is created. Per ulteriori informazioni, vedere Procedura: Aggiungere tag all'installazione di un dispositivo per abilitare il push dei tag.For more information, see How to: Add tags to a device installation to enable push-to-tags.

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

    protected override void OnMessage(Context context, Intent intent)
    {          
        string message = string.Empty;
    
        // Extract the push notification message from the intent.
        if (intent.Extras.ContainsKey("message"))
        {
            message = intent.Extras.Get("message").ToString();
            var title = "New item added:";
    
            // Create a notification manager to send the notification.
            var notificationManager = 
                GetSystemService(Context.NotificationService) as NotificationManager;
    
            // Create a new intent to show the notification in the UI. 
            PendingIntent contentIntent = 
                PendingIntent.GetActivity(context, 0, 
                new Intent(this, typeof(ToDoActivity)), 0);              
    
            // Create the notification using the builder.
            var builder = new Notification.Builder(context);
            builder.SetAutoCancel(true);
            builder.SetContentTitle(title);
            builder.SetContentText(message);
            builder.SetSmallIcon(Resource.Drawable.ic_launcher);
            builder.SetContentIntent(contentIntent);
            var notification = builder.Build();
    
            // Display the notification in the Notifications Area.
            notificationManager.Notify(1, notification);
    
        }
    }
    
  8. Eseguire l'override dei metodi OnUnRegistered() e OnError() con il codice seguente.Override the OnUnRegistered() and OnError() methods with the following code.

    protected override void OnUnRegistered(Context context, string registrationId)
    {
        throw new NotImplementedException();
    }
    
    protected override void OnError(Context context, string errorId)
    {
        System.Diagnostics.Debug.WriteLine(
            string.Format("Error occurred in the notification: {0}.", errorId));
    }
    

Testare le notifiche push nell'appTest push notifications in your app

È possibile testare l'app mediante un dispositivo virtuale nell'emulatore.You can test the app by using a virtual device in the emulator. Ci sono altri passaggi di configurazione richiesti durante l'esecuzione in un emulatore.There are additional configuration steps required when running on an emulator.

  1. Il dispositivo virtuale deve avere le API Google impostate come destinazione nella gestione del dispositivo virtuale Android (AVD).The virtual device must have Google APIs set as the target in the Android Virtual Device (AVD) manager.

  2. Aggiungere un account Google al dispositivo Android facendo clic su Apps (App) > Settings (Impostazioni) > Add account (Aggiungi account), quindi seguire le istruzioni.Add a Google account to the Android device by clicking Apps > Settings > Add account, then follow the prompts.

  3. Eseguire l'app todolist come fatto in precedenza e inserire un nuovo elemento todo.Run the todolist app as before and insert a new todo item. Questa volta, viene visualizzata un'icona di notifica nell'area di notifica.This time, a notification icon is displayed in the notification area. È possibile aprire la cassetta della notifica per visualizzare il testo completo della notifica.You can open the notification drawer to view the full text of the notification.