Aggiungere notifiche push all'app Xamarin.FormsAdd push notifications to your Xamarin.Forms app

PanoramicaOverview

In questa esercitazione vengono aggiunte notifiche push a tutti i progetti creati nella guida introduttiva per Xamarin.Forms,In this tutorial, you add push notifications to all the projects that resulted from the Xamarin.Forms quick start. in modo che a ogni inserimento di record venga inviata una notifica push a tutti i client multipiattaforma.This means that a push notification is sent to all cross-platform clients 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 quick start 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 Work with the .NET backend server SDK for Azure Mobile Apps.

PrerequisitiPrerequisites

Per iOS sono necessari un dispositivo iOS fisico e un'appartenenza all'Apple Developer Program.For iOS, you will need an Apple Developer Program membership and a physical iOS device. Il simulatore iOS non supporta le notifiche push.The iOS simulator does not support push notifications.

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 andare in Servizi app, quindi fare clic sul back-end dell'app.In the [Azure portal], go to App Services, and then click your app back end. In Impostazioni fare clic su Push.Under Settings, click Push.
  2. Fare clic su Connetti per aggiungere una risorsa dell'hub di notifica all'app.Click Connect to add a notification hub resource to the app. È possibile creare un hub o connettersi a uno esistente.You can either create a hub or connect to an existing one.

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à l'hub di notifica per la connessione a un Platform Notification System (PNS) per effettuare il push ai dispositivi.Later you will configure this notification hub to connect to a platform notification system (PNS) to push to devices.

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. Questa operazione si basa sulla funzionalità dei modelli di Hub di notifica di Azure, che abilita i push multipiattaforma.This is powered by the template feature of Azure Notification Hubs, enabling 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, quindi scegliere Gestisci pacchetti NuGet.In Visual Studio, right-click the server project and click Manage NuGet Packages. Cercare Microsoft.Azure.NotificationHubs, quindi fare clic su Installa.Search for Microsoft.Azure.NotificationHubs, and then click Install. Consente di installare la libreria di Hub di notifica per l'invio di notifiche dal back-end.This installs the Notification Hubs library for sending notifications from your back end.
  2. Nel progetto server aprire Controller > TodoItemController.cs e quindi aggiungere le istruzioni using seguenti:In the server project, open Controllers > TodoItemController.cs, and 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);
    
     // Sending the message so that all template registrations that contain "messageParam"
     // will 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");
     }
    

    Ogni volta che viene inserito un nuovo elemento, viene inviata una notifica modello contenente l'elemento item.text.This 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 nel file todoitem.js con il codice seguente:Replace the existing code in todoitem.js with the following:

     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;  
    

    Ogni volta che viene inserito un nuovo elemento, viene inviata una notifica modello contenente l'elemento item.text.This sends a template notification that contains the item.text when a new item is inserted.

  3. Quando si modifica il file nel computer locale, ripubblicare il progetto server.When editing the file on your local computer, republish the server project.

Configurare ed eseguire il progetto Android (facoltativo)Configure and run the Android project (optional)

Completare questa sezione per abilitare le notifiche push per il progetto Xamarin.Forms Droid per Android.Complete this section to enable push notifications for the Xamarin.Forms Droid project for Android.

Abilitare Firebase Cloud Messaging (FCM)Enable Firebase Cloud Messaging (FCM)

  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, fare clic su Add Firebase to your Android app (Aggiungi Firebase all'app Android) e seguire le istruzioni fornite.After your project is created, click Add Firebase to your Android app and follow the instructions provided.

  3. Nella console di Firebase fare clic sul file cog per il progetto e quindi fare clic su Impostazioni progetto.In the Firebase console, click the cog for your project and then click Project Settings.

  4. Fare clic sulla scheda Cloud Messaging nelle impostazioni del progetto e copiare il valore di Chiave server e ID mittente.Click the Cloud Messaging tab in your project settings, and copy the value of the Server key and Sender ID. Questi valori verranno usati in un secondo momento per configurare i criteri di accesso dell'hub di notifica de e il gestore delle notifiche nell'app.These values will be used later to configure the notification hub access policy, and your notification handler in the app.

Configurare il back-end dell'app per dispositivi mobili per inviare richieste push usando FCMConfigure the Mobile Apps back end to send push requests by using FCM

  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 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. Andare in Google (GCM), immettere la chiave del server FCM ottenuta dalla console Firebase, quindi fare clic su Salva.Go to Google (GCM), enter the FCM server key you obtained from the Firebase console, and then click Save.

Il servizio è ora configurato per l'uso di Firebase Cloud Messaging.Your service is now configured to work with Firebase Cloud Messaging.

Aggiungere notifiche push al progetto AndroidAdd push notifications to the Android project

Dopo aver configurato il back-end con FCM, è possibile aggiungere componenti e codici al client per la registrazione in FCM,With the back end configured with FCM, you can add components and codes to the client to register with FCM. iscriversi alle notifiche push con l'Hub di notifica di Azure tramite il back-end dell'app per dispositivi mobili e ricevere notifiche.You can also register for push notifications with Azure Notification Hubs through the Mobile Apps back end, and receive notifications.

  1. Nel progetto Droid fare doppio clic sulla cartella Components (Componenti) e scegliere Get More Components... (Recupera altri componenti...). Cercare quindi il componente Google Cloud Messaging Client (Client Google Cloud Messaging) e aggiungerlo al progetto.In the Droid project, right-click the Components folder, and click Get More Components.... Then search for the Google Cloud Messaging Client component and add it to the project. Questo componente supporta le notifiche push per un progetto Xamarin Android.This component supports push notifications for a Xamarin Android project.
  2. Aprire il file di progetto MainActivity.cs e aggiungere l'istruzione seguente all'inizio del file:Open the MainActivity.cs project file, and add the following statement at the top of the file:

     using Gcm.Client;
    
  3. Aggiungere il codice seguente al metodo OnCreate dopo la chiamata a LoadApplication:Add the following code to the OnCreate method after the call to LoadApplication:

     try
     {
         // Check to ensure everything's set up right
         GcmClient.CheckDevice(this);
         GcmClient.CheckManifest(this);
    
         // Register for push notifications
         System.Diagnostics.Debug.WriteLine("Registering...");
         GcmClient.Register(this, PushHandlerBroadcastReceiver.SENDER_IDS);
     }
     catch (Java.Net.MalformedURLException)
     {
         CreateAndShowDialog("There was an error creating the client. Verify the URL.", "Error");
     }
     catch (Exception e)
     {
         CreateAndShowDialog(e.Message, "Error");
     }
    
  4. Aggiungere un nuovo metodo helper CreateAndShowDialog , come indicato di seguito:Add a new CreateAndShowDialog helper method, as follows:

     private void CreateAndShowDialog(String message, String title)
     {
         AlertDialog.Builder builder = new AlertDialog.Builder(this);
    
         builder.SetMessage (message);
         builder.SetTitle (title);
         builder.Create().Show ();
     }
    
  5. Aggiungere il codice seguente alla classe MainActivity :Add the following code to the MainActivity class:

     // Create a new instance field for this activity.
     static MainActivity instance = null;
    
     // Return the current activity instance.
     public static MainActivity CurrentActivity
     {
         get
         {
             return instance;
         }
     }
    

    Verrà esposta l'istanza corrente di MainActivity, in modo che sia possibile l'esecuzione nel thread principale dell'interfaccia utente.This exposes the current MainActivity instance, so we can execute on the main UI thread.

  6. Inizializzare la variabile instance all'inizio del metodo OnCreate, come indicato di seguito.Initialize the instance variable at the beginning of the OnCreate method, as follows.

     // Set the current instance of MainActivity.
     instance = this;
    
  7. Aggiungere un nuovo file di classe al progetto Droid denominato GcmService.cs, quindi assicurarsi che le istruzioni using seguenti siano presenti nella parte iniziale del file:Add a new class file to the Droid project named GcmService.cs, and make sure the following using statements are present at the top of the file:

     using Android.App;
     using Android.Content;
     using Android.Media;
     using Android.Support.V4.App;
     using Android.Util;
     using Gcm.Client;
     using Microsoft.WindowsAzure.MobileServices;
     using Newtonsoft.Json.Linq;
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.Text;
    
  8. Aggiungere le richieste di autorizzazione seguenti alla parte iniziale del file, dopo le istruzioni using e prima della dichiarazione namespace.Add the following permission requests at the top of the file, after the using statements and before 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")]
     [assembly: UsesPermission(Name = "android.permission.INTERNET")]
     [assembly: UsesPermission(Name = "android.permission.WAKE_LOCK")]
     //GET_ACCOUNTS is only needed for android versions 4.0.3 and below
     [assembly: UsesPermission(Name = "android.permission.GET_ACCOUNTS")]
    
  9. Aggiungere la definizione di classe seguente allo spazio dei nomi.Add the following class definition to the namespace.

    [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 PushHandlerBroadcastReceiver : GcmBroadcastReceiverBase<GcmService>
    {
        public static string[] SENDER_IDS = new string[] { "<PROJECT_NUMBER>" };
    }
    

    Nota

    Sostituire <PROJECT_NUMBER> con il numero di progetto annotato in precedenza.Replace <PROJECT_NUMBER> with your project number you noted earlier.

  10. Sostituire la classe GcmService vuota con il codice seguente, che usa il nuovo ricevitore di trasmissione:Replace the empty GcmService class with the following code, which uses the new broadcast receiver:

     [Service]
     public class GcmService : GcmServiceBase
     {
         public static string RegistrationID { get; private set; }
    
         public GcmService()
             : base(PushHandlerBroadcastReceiver.SENDER_IDS){}
     }
    
  11. Aggiungere il codice seguente alla classe GcmServiceAdd the following code to the GcmService class. in modo da sostituire il gestore eventi OnRegistered e implementare un metodo Register.This overrides the OnRegistered event handler and implements a Register method.

    protected override void OnRegistered(Context context, string registrationId)
    {
        Log.Verbose("PushHandlerBroadcastReceiver", "GCM Registered: " + registrationId);
        RegistrationID = registrationId;
    
        var push = TodoItemManager.DefaultManager.CurrentClient.GetPush();
    
        MainActivity.CurrentActivity.RunOnUiThread(() => Register(push, null));
    }
    
    public async void Register(Microsoft.WindowsAzure.MobileServices.Push push, IEnumerable<string> tags)
    {
        try
        {
            const string templateBodyGCM = "{\"data\":{\"message\":\"$(messageParam)\"}}";
    
            JObject templates = new JObject();
            templates["genericMessage"] = new JObject
            {
                {"body", templateBodyGCM}
            };
    
            await push.RegisterAsync(RegistrationID, templates);
            Log.Info("Push Installation Id", push.InstallationId.ToString());
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine(ex.Message);
            Debugger.Break();
        }
    }
    

    Si noti che questo codice usa il parametro messageParam nella registrazione del modello.Note that this code uses the messageParam parameter in the template registration.

  12. Aggiungere il codice seguente che implementa OnMessage:Add the following code that implements OnMessage:

    protected override void OnMessage(Context context, Intent intent)
    {
        Log.Info("PushHandlerBroadcastReceiver", "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());
        }
    
        //Store the message
        var prefs = GetSharedPreferences(context.PackageName, FileCreationMode.Private);
        var edit = prefs.Edit();
        edit.PutString("last_msg", msg.ToString());
        edit.Commit();
    
        string message = intent.Extras.GetString("message");
        if (!string.IsNullOrEmpty(message))
        {
            createNotification("New todo item!", "Todo item: " + message);
            return;
        }
    
        string msg2 = intent.Extras.GetString("msg");
        if (!string.IsNullOrEmpty(msg2))
        {
            createNotification("New hub message!", msg2);
            return;
        }
    
        createNotification("Unknown message details", msg.ToString());
    }
    
    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));
    
        //Use Notification Builder
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
    
        //Create the notification
        //we use the pending intent, passing our ui intent over which will get called
        //when the notification is tapped.
        var notification = builder.SetContentIntent(PendingIntent.GetActivity(this, 0, uiIntent, 0))
                .SetSmallIcon(Android.Resource.Drawable.SymActionEmail)
                .SetTicker(title)
                .SetContentTitle(title)
                .SetContentText(desc)
    
                //Set the notification sound
                .SetSound(RingtoneManager.GetDefaultUri(RingtoneType.Notification))
    
                //Auto cancel will remove the notification once the user touches it
                .SetAutoCancel(true).Build();
    
        //Show the notification
        notificationManager.Notify(1, notification);
    }
    

    Questa operazione consente di gestire le notifiche in ingresso e di inviarle alla gestione notifiche per la visualizzazione.This handles incoming notifications and sends them to the notification manager to be displayed.

  13. GcmServiceBase richiede anche l'implementazione dei metodi gestore OnUnRegistered e OnError, come illustrato di seguito:GcmServiceBase also requires you to implement the OnUnRegistered and OnError handler methods, which you can do as follows:

    protected override void OnUnRegistered(Context context, string registrationId)
    {
        Log.Error("PushHandlerBroadcastReceiver", "Unregistered RegisterationId : " + registrationId);
    }
    
    protected override void OnError(Context context, string errorId)
    {
        Log.Error("PushHandlerBroadcastReceiver", "GCM Error: " + errorId);
    }
    

È ora possibile testare le notifiche push nell'app in esecuzione su un dispositivo Android o nell'emulatore.Now, you are ready test push notifications in the app running on an Android device or the emulator.

Testare le notifiche push nell'app AndroidTest push notifications in your Android app

I primi due passaggi sono necessari solo per i test eseguiti in un emulatore.The first two steps are required only when you're testing on an emulator.

  1. Assicurarsi di distribuire o eseguire il debug su un dispositivo virtuale che ha le API Google impostate come destinazione, come illustrato di seguito nel gestore del dispositivo virtuale Android.Make sure that you are deploying to or debugging on a virtual device that has Google APIs set as the target, as shown below in the Android Virtual Device manager.
  2. Aggiungere un account Google al dispositivo Android facendo clic su App > Impostazioni > Aggiunti account.Add a Google account to the Android device by clicking Apps > Settings > Add account. Seguire quindi le istruzioni per aggiungere un account Google esistente al dispositivo o per crearne uno nuovo.Then follow the prompts to add an existing Google account to the device, or to create a new one.
  3. In Visual Studio o Xamarin Studio fare clic con il pulsante destro del mouse sul progetto Droid e scegliere Imposta come progetto di avvio.In Visual Studio or Xamarin Studio, right-click the Droid project and click Set as startup project.
  4. Fare clic su Esegui per creare il progetto e avviare l'app sul dispositivo Android o sull'emulatore.Click Run to build the project and start the app on your Android device or emulator.
  5. Nell'app digitare un'attività e fare clic sull'icona con il segno più (+).In the app, type a task, and then click the plus (+) icon.
  6. Assicurarsi di ricevere una notifica quando viene aggiunto un elemento.Verify that a notification is received when an item is added.

Configurare ed eseguire il progetto iOS (facoltativo)Configure and run the iOS project (optional)

Questa sezione illustra l'esecuzione del progetto Xamarin iOS per dispositivi iOS.This section is for running the Xamarin iOS project for iOS devices. Se non si usano dispositivi iOS, è possibile ignorare questa sezione.You can skip this section if you are not working with iOS devices.

Configurare l'hub di notifica per APNSConfigure the notification hub for APNS

  1. In Mac avviare Keychain Access.On your Mac, launch Keychain Access. Aprire My Certificates (Certificati personali) in Categoria nella barra di spostamento sinistra.On the left navigation bar, under Category, open My Certificates. Trovare il certificato SSL scaricato nella sezione precedente e divulgare il contenuto.Find the SSL certificate you downloaded in the previous section, and disclose its contents. Selezionare solo il certificato (non selezionare la chiave privata) ed esportarlo.Select only the certificate (do not select the private key), and export it.
  2. 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 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. Andare a Apple Push Notification Services > Carica certificato.Go to Apple Push Notification Services > Upload Certificate. Caricare il file con estensione p12, selezionando la modalità corretta, a seconda che il certificato SSL client di prima sia di produzione o sandbox.Upload the .p12 file, selecting the correct Mode (depending on whether your client SSL certificate from earlier is production or sandbox). Salvare le modifiche.Save any changes.

Il servizio è ora configurato per l'uso con le notifiche push in iOS.Your service is now configured to work with push notifications on iOS.

In seguito verrà configurata l'impostazione di progetto iOS in Xamarin Studio o Visual Studio.Next, you will configure the iOS project setting in Xamarin Studio or Visual Studio.

Configurazione del progetto iOS in Xamarin StudioConfigure the iOS project in Xamarin Studio

  1. In Xamarin Studio aprire Info.plist e aggiornare il valore in Bundle Identifier (Identificatore bundle) con l'ID creata in precedenza.In Xamarin.Studio, open Info.plist, and update the Bundle Identifier with the bundle ID that you created earlier with your new app ID.

  2. Scorrere verso il basso fino a Background Modes (Modalità in background).Scroll down to Background Modes. Selezionare le caselle Enable Background Modes (Abilita modalità in background) e Remote notifications (Notifiche remote).Select the Enable Background Modes box and the Remote notifications box.

  3. Fare doppio clic sul progetto nel riquadro delle soluzioni per aprire Opzioni progetto.Double-click your project in the Solution Panel to open Project Options.
  4. Scegliere iOS Bundle Signing (Firma bundle iOS) in Genera e selezionare i valori corrispondenti per l'identità e il profilo di provisioning appena configurati per questo progetto.Under Build, choose iOS Bundle Signing, and select the corresponding identity and provisioning profile you just set up for this project.

    Per effetto di questa operazione, il progetto userà il nuovo profilo per la firma del codice.This ensures that the project uses the new profile for code signing. Per la documentazione ufficiale, vedere la pagina relativa al provisioning del dispositivo Xamarin.For the official Xamarin device provisioning documentation, see [Xamarin Device Provisioning].

Configurazione del progetto iOS in Visual StudioConfigure the iOS project in Visual Studio

  1. In Visual Studio fare clic con il pulsante destro del mouse sul progetto e quindi scegliere Proprietà.In Visual Studio, right-click the project, and then click Properties.
  2. Nelle pagine delle proprietà fare clic sulla scheda iOS Application (Applicazione iOS) e aggiornare il campo Identifier (Identificatore) con l'ID creato in precedenza.In the properties pages, click the iOS Application tab, and update the Identifier with the ID that you created earlier.

  3. Nella scheda iOS Bundle Signing (Firma bundle iOS) selezionare i valori corrispondenti per identità e profilo di provisioning appena configurati per questo progetto.In the iOS Bundle Signing tab, select the corresponding identity and provisioning profile you just set up for this project.

    Per effetto di questa operazione, il progetto userà il nuovo profilo per la firma del codice.This ensures that the project uses the new profile for code signing. Per la documentazione ufficiale, vedere la pagina relativa al provisioning del dispositivo Xamarin.For the official Xamarin device provisioning documentation, see [Xamarin Device Provisioning].

  4. Fare doppio clic su Info.plist per aprirlo e abilitare RemoteNotifications in Background Modes (Modalità in background).Double-click Info.plist to open it, and then enable RemoteNotifications under Background Modes.

Aggiungere notifiche push all'app iOSAdd push notifications to your iOS app

  1. Nel progetto iOS aprire il file AppDelegate.cs e aggiungere l'istruzione seguente all'inizio del file di codice.In the iOS project, open AppDelegate.cs and add the following statement to the top of the code file.

     using Newtonsoft.Json.Linq;
    
  2. Nella classe AppDelegate aggiungere un override per l'evento RegisteredForRemoteNotifications per eseguire la registrazione per le notifiche:In the AppDelegate class, add an override for the RegisteredForRemoteNotifications event to register for notifications:

     public override void RegisteredForRemoteNotifications(UIApplication application,
         NSData deviceToken)
     {
         const string templateBodyAPNS = "{\"aps\":{\"alert\":\"$(messageParam)\"}}";
    
         JObject templates = new JObject();
         templates["genericMessage"] = new JObject
             {
               {"body", templateBodyAPNS}
             };
    
         // Register for push with your mobile app
         Push push = TodoItemManager.DefaultManager.CurrentClient.GetPush();
         push.RegisterAsync(deviceToken, templates);
     }
    
  3. In AppDelegate aggiungere anche l'override seguente per il gestore eventi DidReceiveRemoteNotification:In AppDelegate, also add the following override for the DidReceiveRemoteNotification event handler:

     public override void DidReceiveRemoteNotification(UIApplication application,
         NSDictionary userInfo, Action<UIBackgroundFetchResult> completionHandler)
     {
         NSDictionary aps = userInfo.ObjectForKey(new NSString("aps")) as NSDictionary;
    
         string alert = string.Empty;
         if (aps.ContainsKey(new NSString("alert")))
             alert = (aps[new NSString("alert")] as NSString).ToString();
    
         //show alert
         if (!string.IsNullOrEmpty(alert))
         {
             UIAlertView avAlert = new UIAlertView("Notification", alert, null, "OK", null);
             avAlert.Show();
         }
     }
    

    Questo metodo gestisce le notifiche in ingresso mentre l'applicazione è in esecuzione.This method handles incoming notifications while the app is running.

  4. Nella classe AppDelegate aggiungere il codice seguente al metodo FinishedLaunching:In the AppDelegate class, add the following code to the FinishedLaunching method:

     // Register for push notifications.
     var settings = UIUserNotificationSettings.GetSettingsForTypes(
         UIUserNotificationType.Alert
         | UIUserNotificationType.Badge
         | UIUserNotificationType.Sound,
         new NSSet());
    
     UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
     UIApplication.SharedApplication.RegisterForRemoteNotifications();
    

    L'aggiunta di questo codice consente il supporto per le notifiche remote e richiede la registrazione push.This enables support for remote notifications and requests push registration.

L'app è ora aggiornata per il supporto delle notifiche push.Your app is now updated to support push notifications.

Testare le notifiche push nell'app iOSTest push notifications in your iOS app

  1. Fare clic con il pulsante destro del mouse sul progetto iOS e quindi scegliere Imposta come progetto di avvio.Right-click the iOS project, and click Set as StartUp Project.
  2. Scegliere Esegui o premere F5 per compilare il progetto e avviare l'app in un dispositivo iOSPress the Run button or F5 in Visual Studio to build the project and start the app in an iOS device. e quindi fare clic su OK per accettare le notifiche push.Then click OK to accept push notifications.

    Nota

    È necessario accettare le notifiche push in modo esplicito dall'app.You must explicitly accept push notifications from your app. Questa richiesta viene visualizzata solo la prima volta che si esegue l'app.This request only occurs the first time that the app runs.

  3. Nell'app digitare un'attività e fare clic sull'icona con il segno più (+).In the app, type a task, and then click the plus (+) icon.
  4. Verificare che venga ricevuta una notifica e quindi fare clic su OK per ignorarla.Verify that a notification is received, and then click OK to dismiss the notification.

Configurare ed eseguire progetti Windows (facoltativo)Configure and run Windows projects (optional)

Questa sezione illustra l'esecuzione dei progetti Xamarin.Forms WinApp e WinPhone81 per dispositivi Windows.This section is for running the Xamarin.Forms WinApp and WinPhone81 projects for Windows devices. Questa procedura supporta anche progetti per la piattaforma UWP (Universal Windows Platform).These steps also support Universal Windows Platform (UWP) projects. Se non si usano dispositivi Windows, è possibile ignorare questa sezione.You can skip this section if you are not working with Windows devices.

Registrare l'app Windows per le notifiche push con il servizio di notifica Windows (WNS)Register your Windows app for push notifications with Windows Notification Service (WNS)

  1. In Visual Studio Solution Explorer (Esplora soluzioni di Visual Studio), fare clic con il pulsante destro del mouse sul progetto app di Windows Store, quindi scegliere Store > Associa applicazione a Store.In Visual Studio Solution Explorer, right-click the Windows Store app project, and click Store > Associate App with the Store.

    Associa l’app con Windows Store

  2. Nella procedura guidata fare clic su Avanti e accedere con il proprio account Microsoft.In the wizard, click Next, and sign in with your Microsoft account. Immettere un nome per l'app in Riserva un nuovo nome dell'app, fare clic su Riserva.Type a name for your app in Reserve a new app name, and then click Reserve.
  3. Dopo la creazione della registrazione dell'app, selezionare il nuovo nome dell'app, fare clic su Avanti e quindi su Associa.After the app registration is successfully created, select the new app name, click Next, and then click Associate. Le informazioni di registrazione a Windows Store necessarie verranno aggiunte al manifesto dell'applicazione.This adds the required Windows Store registration information to the application manifest.
  4. Ripetere i passaggi 1 e 3 per il progetto app di Windows Phone Store usando la stessa registrazione creata in precedenza per l'app di Windows Store.Repeat steps 1 and 3 for the Windows Phone Store app project by using the same registration you previously created for the Windows Store app.
  5. Aprire il Windows Dev Center e accedervi con l'account Microsoft.Browse to the Windows Dev Center, and sign in with your Microsoft account. Fare clic sulla nuova registrazione di app in App personali, quindi espandere Servizi > Notifiche Push.Click the new app registration in My apps, and then expand Services > Push notifications.
  6. Nella pagina Notifiche Push fare clic su Live Services site (Sito di servizi Live) in Servizi notifica Push Windows (WNS) e App per dispositivi mobili di Microsoft Azure.On the Push notifications page, click Live Services site under Windows Push Notification Services (WNS) and Microsoft Azure Mobile Apps. Prendere nota dei valori del SID pacchetto e del valore attuale in Segreto dell'applicazione.Make a note of the values of the Package SID and the current value in Application Secret.

    Impostazione dell’app nel centro per sviluppatori

    Importante

    Il segreto applicazione e il SID di pacchetto sono importanti credenziali di sicurezza.The application secret and package SID are important security credentials. Non condividere questi valori con altri utenti né distribuirli con l'app.Do not share these values with anyone or distribute them with your app.

Configurare l'hub di notifica per WNSConfigure the notification hub for WNS

  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 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. Andare in Windows (WNS), immettere la chiave di sicurezza (chiave privata client) e il SID di pacchetto ottenuti dal sito di servizi Live, quindi fare clic su Salva.Go to Windows (WNS), enter the Security key (client secret) and Package SID that you obtained from the Live Services site, and then click Save.

    Impostare la chiave WNS nel portale

Il back-end ora è configurato per poter inviare le notifiche push tramite WSN.Your back end is now configured to use WNS to send push notifications.

Aggiungere notifiche push all'app di WindowsAdd push notifications to your Windows app

  1. In Visual Studio aprire il file App.xaml.cs in un progetto Windows e aggiungere le istruzioni seguenti.In Visual Studio, open App.xaml.cs in a Windows project, and add the following statements.

     using Newtonsoft.Json.Linq;
     using Microsoft.WindowsAzure.MobileServices;
     using System.Threading.Tasks;
     using Windows.Networking.PushNotifications;
     using <your_TodoItemManager_portable_class_namespace>;
    

    Sostituire <your_TodoItemManager_portable_class_namespace> con lo spazio dei nomi del progetto portabile che contiene la classe TodoItemManager.Replace <your_TodoItemManager_portable_class_namespace> with the namespace of your portable project that contains the TodoItemManager class.

  2. Nel file App.xaml.cs aggiungere il metodo InitNotificationsAsync seguente:In App.xaml.cs, add the following InitNotificationsAsync method:

     private async Task InitNotificationsAsync()
     {
         var channel = await PushNotificationChannelManager
             .CreatePushNotificationChannelForApplicationAsync();
    
         const string templateBodyWNS =
             "<toast><visual><binding template=\"ToastText01\"><text id=\"1\">$(messageParam)</text></binding></visual></toast>";
    
         JObject headers = new JObject();
         headers["X-WNS-Type"] = "wns/toast";
    
         JObject templates = new JObject();
         templates["genericMessage"] = new JObject
         {
             {"body", templateBodyWNS},
             {"headers", headers} // Needed for WNS.
         };
    
         await TodoItemManager.DefaultManager.CurrentClient.GetPush()
             .RegisterAsync(channel.Uri, templates);
     }
    

    Questo metodo ottiene il canale per la notifica push e registra un modello per la ricezione di notifiche di modello dall'hub di notifica.This method gets the push notification channel, and registers a template to receive template notifications from your notification hub. A questo client verrà recapitata una notifica di modello che supporta messageParam .A template notification that supports messageParam will be delivered to this client.

  3. Nel file App.xaml.cs aggiornare la definizione del metodo OnLaunched del gestore eventi aggiungendo il modificatore asyncIn App.xaml.cs, update the OnLaunched event handler method definition by adding the async modifier. e quindi aggiungere la riga di codice seguente alla fine del metodo:Then add the following line of code at the end of the method:

     await InitNotificationsAsync();
    

    In questo modo è possibile garantire che la registrazione della notifica push venga creata o aggiornata a ogni avvio dell'app.This ensures that the push notification registration is created or refreshed every time the app is launched. È importante eseguire questa operazione per assicurare che il canale di notifica push WNS sia sempre attivo.It's important to do this to guarantee that the WNS push channel is always active.

  4. In Esplora soluzioni di Visual Studio aprire il file Package.appxmanifest e in Notifiche impostare Avvisi popup supportati su .In Solution Explorer for Visual Studio, open the Package.appxmanifest file, and set Toast Capable to Yes under Notifications.
  5. Compilare l'app e verificare che non siano presenti errori.Build the app and verify you have no errors. A questo punto l'app client dovrebbe eseguire la registrazione per le notifiche di modello dal back-end dell'app per dispositivi mobili.Your client app should now register for the template notifications from the Mobile Apps back end. Ripetere questa sezione per ogni progetto Windows nella soluzione.Repeat this section for every Windows project in your solution.

Testare le notifiche push nell'app di WindowsTest push notifications in your Windows app

  1. In Visual Studio fare clic con il pulsante destro del mouse su un progetto Windows e quindi scegliere Imposta come progetto di avvio.In Visual Studio, right-click a Windows project, and click Set as startup project.
  2. Premere il pulsante Esegui per compilare il progetto e avviare l'app.Press the Run button to build the project and start the app.
  3. Nell'app digitare un nome per un nuovo elemento todoitem, quindi fare clic sull'icona del segno più (+) per aggiungerlo.In the app, type a name for a new todoitem, and then click the plus (+) icon to add it.
  4. Assicurarsi di ricevere una notifica quando viene aggiunto l'elemento.Verify that a notification is received when the item is added.

Passaggi successiviNext steps

Altre informazioni sulle notifiche push:You can learn more about push notifications:

  • Diagnose push notification issuesDiagnose push notification issues
    (Diagnosticare i problemi relativi alle notifiche push) Esistono varie ragioni per cui le notifiche possono essere eliminate o non giungere ai dispositivi.There are various reasons why notifications may get dropped or do not end up on devices. Questo argomento illustra come analizzare e capire la causa radice degli errori relativi alle notifiche push.This topic shows you how to analyze and figure out the root cause of push notification failures.

È possibile anche proseguire con una delle esercitazioni seguenti:You can also continue on to one of the following tutorials:

  • Add authentication to your app Add authentication to your app
    (Aggiungere l'autenticazione all'app) Informazioni sull'autenticazione degli utenti dell'app con un provider di identità.Learn how to authenticate users of your app with an identity provider.
  • Abilitare la sincronizzazione offline per l'app per dispositivi mobili Xamarin.FormsEnable offline sync for your app
    Informazioni su come aggiungere il supporto offline all'app usando il back-end di un'app per dispositivi mobili.Learn how to add offline support for your app by using a Mobile Apps back end. Con la sincronizzazione offline è possibile interagire con un'app per dispositivi mobili —visualizzando, aggiungendo e modificando i dati— anche se non è disponibile una connessione di rete.With offline sync, users can interact with a mobile app—viewing, adding, or modifying data—even when there is no network connection.