Aggiungere notifiche push all'app Xamarin.Forms

Panoramica

In questa esercitazione vengono aggiunte notifiche push a tutti i progetti creati nella guida introduttiva per Xamarin.Forms, in modo che a ogni inserimento di record venga inviata una notifica push a tutti i client multipiattaforma.

Se non si usa il progetto server di avvio rapido scaricato, sarà necessario aggiungere il pacchetto di estensione di notifica push. Per altre informazioni, vedere Usare l'SDK del server back-end .NET per App per dispositivi mobili di Azure.

Prerequisiti

Per iOS sono necessari un dispositivo iOS fisico e un'appartenenza all'Apple Developer Program. Il simulatore iOS non supporta le notifiche push.

Configurare un hub di notifica

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.

  1. Nel Portale di Azure andare in Servizi app, quindi fare clic sul back-end dell'app. In Impostazioni fare clic su Push.
  2. Fare clic su Connetti per aggiungere una risorsa dell'hub di notifica all'app. È possibile creare un hub o connettersi a uno esistente.

A questo punto un hub di notifica è stato connesso al progetto di back-end dell'app per dispositivi mobili. In seguito si configurerà l'hub di notifica per la connessione a un Platform Notification System (PNS) per effettuare il push ai dispositivi.

Aggiornare il progetto server per l'invio di notifiche push

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. Questa operazione si basa sulla funzionalità dei modelli di Hub di notifica di Azure, che abilita i push multipiattaforma. I diversi client vengono registrati per le notifiche push usando i modelli e un unico push universale può raggiungere tutte le piattaforme client.

Scegliere una delle seguenti procedure che corrisponde al tipo di progetto di back-end—, che sia back-end .NET o back-end Node.js.

Progetto di back-end .NET

  1. In Visual Studio fare clic con il pulsante destro del mouse sul progetto server, quindi scegliere Gestisci pacchetti NuGet. Cercare Microsoft.Azure.NotificationHubs, quindi fare clic su Installa. Consente di installare la libreria di Hub di notifica per l'invio di notifiche dal back-end.
  2. Nel progetto server aprire Controller > TodoItemController.cs e quindi aggiungere le istruzioni using seguenti:

     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:

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

  4. Pubblicare di nuovo il progetto server.

Progetto di back-end Node.js

  1. Se ancora non è stato fatto, scaricare il progetto di back-end di avvio rapido oppure usare l'editor online del Portale di Azure.
  2. Sostituire il codice esistente nel file todoitem.js con il codice seguente:

     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.

  3. Quando si modifica il file nel computer locale, ripubblicare il progetto server.

Configurare ed eseguire il progetto Android (facoltativo)

Completare questa sezione per abilitare le notifiche push per il progetto Xamarin.Forms Droid per Android.

Abilitare Firebase Cloud Messaging (FCM)

  1. Accedere alla console di Firebase. Creare un nuovo progetto Firebase se non è già disponibile.
  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.

  3. Nella console di Firebase fare clic sul file cog per il progetto e quindi fare clic su Impostazioni progetto.

  4. Fare clic sulla scheda Cloud Messaging nelle impostazioni del progetto e copiare il valore di Chiave server e ID mittente. 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.

Configurare il back-end dell'app per dispositivi mobili per inviare richieste push usando 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 Impostazioni fare clic su App Service Push (Push servizio app), quindi fare clic sul nome dell'hub di notifica.
  2. Andare in Google (GCM), immettere la chiave del server FCM ottenuta dalla console Firebase, quindi fare clic su Salva.

Il servizio è ora configurato per l'uso di Firebase Cloud Messaging.

Aggiungere notifiche push al progetto Android

Dopo aver configurato il back-end con FCM, è possibile aggiungere componenti e codici al client per la registrazione in FCM, iscriversi alle notifiche push con l'Hub di notifica di Azure tramite il back-end dell'app per dispositivi mobili e ricevere notifiche.

  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. Questo componente supporta le notifiche push per un progetto Xamarin Android.
  2. Aprire il file di progetto MainActivity.cs e aggiungere l'istruzione seguente all'inizio del file:

     using Gcm.Client;
    
  3. Aggiungere il codice seguente al metodo OnCreate dopo la chiamata a 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:

     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 :

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

  6. Inizializzare la variabile instance all'inizio del metodo OnCreate, come indicato di seguito.

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

     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.

     [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.

    [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.

  10. Sostituire la classe GcmService vuota con il codice seguente, che usa il nuovo ricevitore di trasmissione:

     [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 GcmService in modo da sostituire il gestore eventi OnRegistered e implementare un metodo Register.

    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.

  12. Aggiungere il codice seguente che implementa 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.

  13. GcmServiceBase richiede anche l'implementazione dei metodi gestore OnUnRegistered e OnError, come illustrato di seguito:

    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.

Testare le notifiche push nell'app Android

I primi due passaggi sono necessari solo per i test eseguiti in un emulatore.

  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.
  2. Aggiungere un account Google al dispositivo Android facendo clic su App > Impostazioni > Aggiunti account. Seguire quindi le istruzioni per aggiungere un account Google esistente al dispositivo o per crearne uno nuovo.
  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.
  4. Fare clic su Esegui per creare il progetto e avviare l'app sul dispositivo Android o sull'emulatore.
  5. Nell'app digitare un'attività e fare clic sull'icona con il segno più (+).
  6. Assicurarsi di ricevere una notifica quando viene aggiunto un elemento.

Configurare ed eseguire il progetto iOS (facoltativo)

Questa sezione illustra l'esecuzione del progetto Xamarin iOS per dispositivi iOS. Se non si usano dispositivi iOS, è possibile ignorare questa sezione.

Configurare l'hub di notifica per APNS

  1. In Mac avviare Keychain Access. Aprire My Certificates (Certificati personali) in Categoria nella barra di spostamento sinistra. Trovare il certificato SSL scaricato nella sezione precedente e divulgare il contenuto. Selezionare solo il certificato (non selezionare la chiave privata) ed esportarlo.
  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 Impostazioni fare clic su App Service Push (Push servizio app), quindi fare clic sul nome dell'hub di notifica. Andare a Apple Push Notification Services > Carica certificato. Caricare il file con estensione p12, selezionando la modalità corretta, a seconda che il certificato SSL client di prima sia di produzione o sandbox. Salvare le modifiche.

Il servizio è ora configurato per l'uso con le notifiche push in iOS.

In seguito verrà configurata l'impostazione di progetto iOS in Xamarin Studio o Visual Studio.

Configurazione del progetto iOS 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.

  2. Scorrere verso il basso fino a Background Modes (Modalità in background). Selezionare le caselle Enable Background Modes (Abilita modalità in background) e Remote notifications (Notifiche remote).

  3. Fare doppio clic sul progetto nel riquadro delle soluzioni per aprire Opzioni progetto.
  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.

    Per effetto di questa operazione, il progetto userà il nuovo profilo per la firma del codice. Per la documentazione ufficiale, vedere la pagina relativa al provisioning del dispositivo Xamarin.

Configurazione del progetto iOS in Visual Studio

  1. In Visual Studio fare clic con il pulsante destro del mouse sul progetto e quindi scegliere Proprietà.
  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.

  3. Nella scheda iOS Bundle Signing (Firma bundle iOS) selezionare i valori corrispondenti per identità e profilo di provisioning appena configurati per questo progetto.

    Per effetto di questa operazione, il progetto userà il nuovo profilo per la firma del codice. Per la documentazione ufficiale, vedere la pagina relativa al provisioning del dispositivo Xamarin.

  4. Fare doppio clic su Info.plist per aprirlo e abilitare RemoteNotifications in Background Modes (Modalità in background).

Aggiungere notifiche push all'app iOS

  1. Nel progetto iOS aprire il file AppDelegate.cs e aggiungere l'istruzione seguente all'inizio del file di codice.

     using Newtonsoft.Json.Linq;
    
  2. Nella classe AppDelegate aggiungere un override per l'evento RegisteredForRemoteNotifications per eseguire la registrazione per le notifiche:

     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:

     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.

  4. Nella classe AppDelegate aggiungere il codice seguente al metodo FinishedLaunching:

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

L'app è ora aggiornata per il supporto delle notifiche push.

Testare le notifiche push nell'app iOS

  1. Fare clic con il pulsante destro del mouse sul progetto iOS e quindi scegliere Imposta come progetto di avvio.
  2. Scegliere Esegui o premere F5 per compilare il progetto e avviare l'app in un dispositivo iOS e quindi fare clic su OK per accettare le notifiche push.

    Nota

    È necessario accettare le notifiche push in modo esplicito dall'app. Questa richiesta viene visualizzata solo la prima volta che si esegue l'app.

  3. Nell'app digitare un'attività e fare clic sull'icona con il segno più (+).
  4. Verificare che venga ricevuta una notifica e quindi fare clic su OK per ignorarla.

Configurare ed eseguire progetti Windows (facoltativo)

Questa sezione illustra l'esecuzione dei progetti Xamarin.Forms WinApp e WinPhone81 per dispositivi Windows. Questa procedura supporta anche progetti per la piattaforma UWP (Universal Windows Platform). Se non si usano dispositivi Windows, è possibile ignorare questa sezione.

Registrare l'app Windows per le notifiche push con il servizio di notifica Windows (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.

    Associa l’app con Windows Store

  2. Nella procedura guidata fare clic su Avanti e accedere con il proprio account Microsoft. Immettere un nome per l'app in Riserva un nuovo nome dell'app, fare clic su Riserva.
  3. Dopo la creazione della registrazione dell'app, selezionare il nuovo nome dell'app, fare clic su Avanti e quindi su Associa. Le informazioni di registrazione a Windows Store necessarie verranno aggiunte al manifesto dell'applicazione.
  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.
  5. Aprire il Windows Dev Center e accedervi con l'account Microsoft. Fare clic sulla nuova registrazione di app in App personali, quindi espandere Servizi > Notifiche Push.
  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. Prendere nota dei valori del SID pacchetto e del valore attuale in Segreto dell'applicazione.

    Impostazione dell’app nel centro per sviluppatori

    Importante

    Il segreto applicazione e il SID di pacchetto sono importanti credenziali di sicurezza. Non condividere questi valori con altri utenti né distribuirli con l'app.

Configurare l'hub di notifica per 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 Impostazioni fare clic su App Service Push (Push servizio app), quindi fare clic sul nome dell'hub di notifica.
  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.

    Impostare la chiave WNS nel portale

Il back-end ora è configurato per poter inviare le notifiche push tramite WSN.

Aggiungere notifiche push all'app di Windows

  1. In Visual Studio aprire il file App.xaml.cs in un progetto Windows e aggiungere le istruzioni seguenti.

     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.

  2. Nel file App.xaml.cs aggiungere il metodo InitNotificationsAsync seguente:

     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. A questo client verrà recapitata una notifica di modello che supporta messageParam .

  3. Nel file App.xaml.cs aggiornare la definizione del metodo OnLaunched del gestore eventi aggiungendo il modificatore async e quindi aggiungere la riga di codice seguente alla fine del metodo:

     await InitNotificationsAsync();
    

    In questo modo è possibile garantire che la registrazione della notifica push venga creata o aggiornata a ogni avvio dell'app. È importante eseguire questa operazione per assicurare che il canale di notifica push WNS sia sempre attivo.

  4. In Esplora soluzioni di Visual Studio aprire il file Package.appxmanifest e in Notifiche impostare Avvisi popup supportati su .
  5. Compilare l'app e verificare che non siano presenti errori. A questo punto l'app client dovrebbe eseguire la registrazione per le notifiche di modello dal back-end dell'app per dispositivi mobili. Ripetere questa sezione per ogni progetto Windows nella soluzione.

Testare le notifiche push nell'app di Windows

  1. In Visual Studio fare clic con il pulsante destro del mouse su un progetto Windows e quindi scegliere Imposta come progetto di avvio.
  2. Premere il pulsante Esegui per compilare il progetto e avviare l'app.
  3. Nell'app digitare un nome per un nuovo elemento todoitem, quindi fare clic sull'icona del segno più (+) per aggiungerlo.
  4. Assicurarsi di ricevere una notifica quando viene aggiunto l'elemento.

Passaggi successivi

Altre informazioni sulle notifiche push:

  • Diagnose 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. Questo argomento illustra come analizzare e capire la causa radice degli errori relativi alle notifiche push.

È possibile anche proseguire con una delle esercitazioni seguenti: