Aggiungere notifiche push alla tua app Xamarin.Forms

Androide
Cordova
Ios
Windows
Xamarin.Android
Xamarin.iOS
Xamarin.Forms

Informazioni generali

In questa esercitazione vengono aggiunte notifiche push a tutti i progetti risultanti dall'avvio rapido di Xamarin.Forms. Ciò significa che una notifica push viene inviata a tutti i client multipiattaforma ogni volta che viene inserito un record.

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

Prerequisiti

Per iOS, è necessaria un'appartenenza a Apple Developer Program e un dispositivo iOS fisico. Il simulatore iOS non supporta le notifiche push.

Configurare un hub di notifica

La funzionalità App per dispositivi mobili del servizio app di Azure usa Hub di notifica di Azure per inviare push, quindi si configurerà un hub di notifica per l'app per dispositivi mobili.

Nel portale di Azure , vai a App servicese quindi seleziona il back-end della tua app. Nelle Impostazioni, selezionare Push.
Per aggiungere una risorsa hub di notifica all'app, selezionare Connetti. È possibile creare un hub o connettersi a un hub esistente.

A questo punto è stato connesso un hub di notifica al progetto back-end di App per dispositivi mobili. Successivamente si configura questo hub di notifica per connettersi a un sistema di notifica della piattaforma (PNS) per eseguire il push nei dispositivi.

Aggiornare il progetto server per inviare notifiche push

In questa sezione si aggiorna il codice nel progetto back-end di App per dispositivi mobili esistente per inviare una notifica push ogni volta che viene aggiunto un nuovo elemento. Questo processo è alimentato dalla funzionalità del modello di Hub di notifica di Azure, che consente push multipiattaforma. I vari client vengono registrati per le notifiche push usando modelli e un singolo push universale può arrivare a tutte le piattaforme client.

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

Progetto .NET back-end

In Visual Studio fare clic con il pulsante destro del mouse sul progetto server. Selezionare quindi Gestisci pacchetti NuGet. Cercare Microsoft.Azure.NotificationHubse quindi selezionare Installa. Questo processo installa la libreria di Hub di notifica per l'invio di notifiche dal back-end.

Nel progetto server aprire i controller >TodoItemController.cs. Quindi, aggiungere le seguenti istruzioni using:

using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;

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

// 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 basata su modello che contiene item.Text quando viene inserito un nuovo elemento.

Ripubblica il progetto del server.

Progetto back-end Node.js

Configurare il progetto backend.

Sostituire il codice esistente in 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 https://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 di modello contenente item.text quando viene inserito un nuovo elemento.

Quando modifichi il file sul computer locale, ripubblica il progetto del server.

Configurare ed eseguire il progetto Android (facoltativo)

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

Abilitare Firebase Cloud Messaging (FCM)

Accedere alla console di Firebase. Crea un nuovo progetto Firebase se non ne hai già uno.
Dopo aver creato il progetto, selezionare Add Firebase to your Android app (Aggiungi Firebase all'app Android).
Nella pagina Aggiungere Firebase all'app Android seguire questa procedura:
1. Per Android package name (Nome pacchetto Android), copiare il valore di applicationId nel file build.gradle dell'applicazione. In questo esempio è com.fabrikam.fcmtutorial1app.
2. Selezionare Registra l'app.
Selezionare Download google-services.json (Scarica google-services.json), salvare il file nella cartella app del progetto e quindi selezionare Avanti.
Apportare le seguenti modifiche di configurazione al progetto in Android Studio.
1. Nel file project-level build.gradle (<project>/build.gradle) aggiungere l'istruzione seguente alla sezione dependencies.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Nel file build.gradle a livello di app (<progetto>/<app-module>/build.gradle), aggiungere le istruzioni seguenti alla sezione dependencies .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Aggiungere la riga seguente alla fine del file app-level build.gradle dopo la sezione dependencies.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selezionare Sincronizza ora sulla barra degli strumenti.
Seleziona Avanti.
Selezionare Ignora questo passaggio.
Nella console di Firebase, selezionare l'ingranaggio per il proprio progetto. Selezionare quindi Project Settings (Impostazioni progetto).
Se il file google-services.json non è stato scaricato nella cartella app del progetto di Android Studio, è possibile eseguire questa operazione in questa pagina.
Passare alla scheda Cloud Messaging in alto.
Copiare e salvare la Chiave server per utilizzi futuri. Questo valore viene usato per configurare l'hub.

Configurare il back-end di App per dispositivi mobili per inviare richieste push tramite FCM

Nel portale di Azure selezionare Esplora tutti i Servizi App>. Selezionare quindi il back-end delle app per dispositivi mobili.
Nelle Impostazioni, selezionare Push. Selezionare quindi Configurare i servizi di notifica push.
Passare a Google (GCM). Immettere la chiave del server legacy FCM ottenuta dalla console Firebase e quindi selezionare Salva.

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

Aggiungere notifiche push al progetto Android

Con il back-end configurato con FCM, è possibile aggiungere componenti e codici al client per la registrazione con FCM. È anche possibile registrarsi per le notifiche push con Hub di notifica di Azure tramite il back-end di App per dispositivi mobili e ricevere notifiche.

Nel progetto Droid fare clic con il pulsante destro del mouse su Riferimenti > Gestisci pacchetti NuGet ....
Nella finestra Gestione pacchetti NuGet cercare il pacchetto Xamarin.Firebase.Messaging e aggiungerlo al progetto.
Nelle proprietà del progetto Droid impostare l'app per la compilazione usando Android versione 7.0 o successiva.
Aggiungere il file google-services.json , scaricato dalla console Firebase, alla radice del progetto Droid e impostarne l'azione di compilazione su GoogleServicesJson. Per altre informazioni, vedere Aggiungere il file JSON di Servizi Google.

Registrazione con Firebase Cloud Messaging

Aprire il fileAndroidManifest.xml e inserire gli elementi seguenti <receiver> nell'elemento <application> :

<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdInternalReceiver" android:exported="false" />
<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdReceiver" android:exported="true" android:permission="com.google.android.c2dm.permission.SEND">
    <intent-filter>
    <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
    <category android:name="${applicationId}" />
    </intent-filter>
</receiver>

Implementazione del servizio Firebase Instance ID

Aggiungere una nuova classe al progetto Droid denominato FirebaseRegistrationServicee assicurarsi che nella parte superiore del file siano presenti le istruzioni seguenti using :
```
using System.Threading.Tasks;
using Android.App;
using Android.Util;
using Firebase.Iid;
using Microsoft.WindowsAzure.MobileServices;
```
Sostituire la classe vuota FirebaseRegistrationService con il codice seguente:
```
[Service]
[IntentFilter(new[] { "com.google.firebase.INSTANCE_ID_EVENT" })]
public class FirebaseRegistrationService : FirebaseInstanceIdService
{
    const string TAG = "FirebaseRegistrationService";

    public override void OnTokenRefresh()
    {
        var refreshedToken = FirebaseInstanceId.Instance.Token;
        Log.Debug(TAG, "Refreshed token: " + refreshedToken);
        SendRegistrationTokenToAzureNotificationHub(refreshedToken);
    }

    void SendRegistrationTokenToAzureNotificationHub(string token)
    {
        // Update notification hub registration
        Task.Run(async () =>
        {
            await AzureNotificationHubService.RegisterAsync(TodoItemManager.DefaultManager.CurrentClient.GetPush(), token);
        });
    }
}
```
La FirebaseRegistrationService classe è responsabile della generazione di token di sicurezza che autorizzano l'applicazione ad accedere a FCM. Il OnTokenRefresh metodo viene richiamato quando l'applicazione riceve un token di registrazione da FCM. Il metodo recupera il token dalla FirebaseInstanceId.Instance.Token proprietà , che viene aggiornato in modo asincrono da FCM. Il OnTokenRefresh metodo viene richiamato raramente, perché il token viene aggiornato solo quando l'applicazione viene installata o disinstallata, quando l'utente elimina i dati dell'applicazione, quando l'applicazione cancella l'ID istanza o quando la sicurezza del token è stata compromessa. Inoltre, il servizio FCM Instance ID richiederà che l'applicazione aggiorni periodicamente il token, in genere ogni 6 mesi.

Il OnTokenRefresh metodo richiama anche il SendRegistrationTokenToAzureNotificationHub metodo , usato per associare il token di registrazione dell'utente all'hub di notifica di Azure.

Registrazione con l'hub di notifica di Azure

Aggiungere una nuova classe al progetto Droid denominato AzureNotificationHubServicee assicurarsi che nella parte superiore del file siano presenti le istruzioni seguenti using :
```
using System;
using System.Threading.Tasks;
using Android.Util;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;
```

Sostituire la classe vuota AzureNotificationHubService con il codice seguente:

public class AzureNotificationHubService
{
    const string TAG = "AzureNotificationHubService";

    public static async Task RegisterAsync(Push push, string token)
    {
        try
        {
            const string templateBody = "{\"data\":{\"message\":\"$(messageParam)\"}}";
            JObject templates = new JObject();
            templates["genericMessage"] = new JObject
            {
                {"body", templateBody}
            };

            await push.RegisterAsync(token, templates);
            Log.Info("Push Installation Id: ", push.InstallationId.ToString());
        }
        catch (Exception ex)
        {
            Log.Error(TAG, "Could not register with Notification Hub: " + ex.Message);
        }
    }
}

Il RegisterAsync metodo crea un modello di messaggio di notifica semplice come JSON e registra per ricevere notifiche modello dall'hub di notifica, usando il token di registrazione Firebase. In questo modo, tutte le notifiche inviate dall'hub di notifica di Azure saranno destinate al dispositivo rappresentato dal token di registrazione.

Visualizzazione del contenuto di una notifica push

Aggiungere una nuova classe al progetto Droid denominato FirebaseNotificationServicee assicurarsi che nella parte superiore del file siano presenti le istruzioni seguenti using :
```
using Android.App;
using Android.Content;
using Android.Media;
using Android.Support.V7.App;
using Android.Util;
using Firebase.Messaging;
```

Sostituire la classe vuota FirebaseNotificationService con il codice seguente:

[Service]
[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
public class FirebaseNotificationService : FirebaseMessagingService
{
    const string TAG = "FirebaseNotificationService";

    public override void OnMessageReceived(RemoteMessage message)
    {
        Log.Debug(TAG, "From: " + message.From);

        // Pull message body out of the template
        var messageBody = message.Data["message"];
        if (string.IsNullOrWhiteSpace(messageBody))
            return;

        Log.Debug(TAG, "Notification message body: " + messageBody);
        SendNotification(messageBody);
    }

    void SendNotification(string messageBody)
    {
        var intent = new Intent(this, typeof(MainActivity));
        intent.AddFlags(ActivityFlags.ClearTop);
        //Unique request code to avoid PendingIntent collision.
        var requestCode = new Random().Next();
        var pendingIntent = PendingIntent.GetActivity(this, requestCode, intent, PendingIntentFlags.OneShot);
        var notificationBuilder = new NotificationCompat.Builder(this)
            .SetSmallIcon(Resource.Drawable.ic_stat_ic_notification)
            .SetContentTitle("New Todo Item")
            .SetContentText(messageBody)
            .SetContentIntent(pendingIntent)
            .SetSound(RingtoneManager.GetDefaultUri(RingtoneType.Notification))
            .SetAutoCancel(true);

        var notificationManager = NotificationManager.FromContext(this);
        notificationManager.Notify(0, notificationBuilder.Build());
    }
}

Il OnMessageReceived metodo , richiamato quando un'applicazione riceve una notifica da FCM, estrae il contenuto del messaggio e chiama il SendNotification metodo . Questo metodo converte il contenuto del messaggio in una notifica locale avviata mentre l'applicazione è in esecuzione, con la notifica visualizzata nell'area di notifica.

A questo momento, è possibile testare le notifiche push nell'app in esecuzione in un dispositivo Android o nell'emulatore.

Testare le notifiche push nell'app Android

I primi due passaggi sono necessari solo quando si esegue il test in un emulatore.

Assicurarsi di eseguire la distribuzione o il debug in un dispositivo o un emulatore configurato con Google Play Services. Questa operazione può essere verificata controllando che le app Play siano installate nel dispositivo o nell'emulatore.
Aggiungere un account Google al dispositivo Android facendo clic suImpostazioni>app>Aggiungi account. Seguire quindi le istruzioni per aggiungere un account Google esistente al dispositivo o crearne uno nuovo.
In Visual Studio o Xamarin Studio fare clic con il pulsante destro del mouse sul progetto Droid e scegliere Imposta come progetto di avvio.
Fare clic su Esegui per compilare il progetto e avviare l'app nel dispositivo o nell'emulatore Android.
Nell'app, digita un'attività e poi fai clic sull'icona del segno più (+).
Verificare che venga ricevuta una notifica quando viene aggiunto un elemento.

Configurare ed eseguire il progetto iOS (facoltativo)

Questa sezione riguarda l'esecuzione del progetto Xamarin iOS per i dispositivi iOS. È possibile ignorare questa sezione se non si lavora con i dispositivi iOS.

Generare il file della richiesta di firma del certificato

Apple Push Notification Service (APN) usa i certificati per autenticare le notifiche push. Seguire queste istruzioni per creare il certificato push necessario per inviare e ricevere notifiche. Per altre informazioni su questi concetti, vedere la documentazione ufficiale Apple Push Notification Service.

Generare il file csr (Certificate Signing Request), usato da Apple per generare un certificato push firmato.

Sul Mac eseguire lo strumento Accesso Portachiavi. Può essere aperto dalla cartella Utilities (Utility) o Other (Altro) nella finestra di avvio.
Selezionare Accesso Portachiavi, espandere Certificate Assistant (Assistente certificati) e quindi selezionare Request a Certificate from a Certificate Authority (Richiedi certificato da Autorità di certificazione).

Annotazioni

Per impostazione predefinita, Accesso Portachiavi seleziona la prima voce dell'elenco. Ciò potrebbe causare problemi se la prima voce dell'elenco nella sezione Certificates (Certificati) non è Apple Worldwide Developer Relations Certification Authority (Autorità di certificazione relazioni sviluppatori Apple a livello mondiale). Prima di generare la richiesta di firma del certificato, verificare che sia presente una voce non di chiave oppure che sia selezionata la chiave Apple Worldwide Developer Relations Certification Authority.
Selezionare User Email Address (Indirizzo di posta elettronica utente), immettere il valore Common Name (Nome comune), assicurarsi di specificare Saved to disk (Salvata su disco) e quindi selezionare Continue (Continua). Lasciare vuoto il campo CA Email Address (Indirizzo di posta elettronica CA), in quanto non è obbligatorio.
Immettere un nome per il file CSR in Save As (Salva con nome), selezionare il percorso in Where (Percorso) e quindi selezionare Save (Salva).

Questa azione consente di salvare il file CSR nel percorso selezionato. Il percorso predefinito è Desktop. Tenere a mente il percorso scelto per il file.

A questo punto registrare l'app con Apple, abilitare le notifiche push e caricare il file CSR esportato per creare un certificato push.

Registrare l'app per le notifiche push

Per inviare notifiche push a un'app per iOS, registrare l'applicazione con Apple ed eseguire un'altra registrazione per abilitare le notifiche push.

Se non hai ancora registrato l'app, vai all'iOS Provisioning Portal nell'Apple Developer Center. Accedere al portale con l'ID Apple e selezionare Identifiers (Identificatori). Selezionare quindi + per registrare una nuova app.
Nella schermata Register a New Identifier (Registra un nuovo identificatore) selezionare il pulsante di opzione App IDs (ID app). Selezionare quindi Continua.
Aggiornare i tre valori seguenti per la nuova app e quindi selezionare Continue (Continua).
- Descrizione: digitare un nome descrittivo per l'app.
- ID bundle: immettere un ID bundle del formato Identificatore organizzazione.Nome prodotto come indicato nella Guida alla distribuzione dell'app. I valori Organization Identifier (Identificatore organizzazione) e Product Name (Nome prodotto) devono corrispondere all'identificatore dell'organizzazione e al nome del prodotto usati nella creazione del progetto Xcode. Nello screenshot seguente il valore NotificationHubs viene usato come identificatore dell'organizzazione e il valore GetStarted viene usato come nome del prodotto. Assicurarsi che il valore Bundle Identifier (Identificatore bundle) corrisponda al valore nel progetto Xcode, affinché Xcode usi il profilo di pubblicazione corretto.
- Notifiche push: selezionare l'opzione Notifiche push nella sezione Funzionalità .
  
  Questa azione consente di generare l'ID app e richiede all'utente di confermare le informazioni. Fare clic su Continue (Continua) e quindi selezionare Register per confermare il nuovo ID app.
  
  Dopo aver selezionato Registra, il nuovo ID app viene visualizzato come voce nella pagina Certificati, Identificatori e profili .
Nella pagina Certificates, Identifiers & Profiles (Certificati, identificatori e profili), in Identifiers (Identificatori) individuare la voce relativa all'ID app appena creata e selezionare la riga corrispondente per visualizzare la schermata Edit your App ID Configuration (Modificare la configurazione dell'ID app).

Creazione di un certificato per Hub di notifica

Per consentire all'hub di notifica di usare APNS, è necessario un certificato. Questa operazione può essere eseguita in uno dei due modi seguenti:

Creare un file con estensione p12 che può essere caricato direttamente nell'hub di notifica.
Creare un file con estensione p8 che può essere usato per l'autenticazione basata su token (approccio più recente).

L'approccio più recente presenta numerosi vantaggi (rispetto all'uso dei certificati), come documentato in Autenticazione basata su token (HTTP/2) per APNS. Tuttavia, sono stati forniti passaggi per entrambi gli approcci.

OPZIONE 1: Creazione di un certificato push con estensione p12 che può essere caricato direttamente nell'hub di notifica

Scorrere verso il basso fino all'opzione Push Notifications (Notifiche push) selezionata, quindi selezionare Configure (Configura) per creare il certificato.
Verrà visualizzata la finestra Apple Push Notification service SSL Certificates (Certificati SSL di Apple Push Notification Service). Selezionare il pulsante Crea certificato nella sezione Development SSL Certificate (Certificato SSL di sviluppo ).

Verrà visualizzata la schermata Create a new Certificate (Crea un nuovo certificato).

Annotazioni

Questa esercitazione usa un certificato di sviluppo. La stessa procedura viene usata per registrare un certificato di produzione. Assicurarsi di usare lo stesso tipo di certificato durante l'invio di notifiche.
Selezionare Scegli file, passare al percorso in cui è stato salvato il file CSR dalla prima attività e quindi fare doppio clic sul nome del certificato per caricarlo. Selezionare quindi Continua.
Dopo che il portale avrà creato il certificato, fare clic sul pulsante Download (Scarica). Salvare il certificato e ricordare il percorso di salvataggio.

Il certificato viene scaricato e salvato nel computer nella cartella Download .

Annotazioni

Per impostazione predefinita, il certificato di sviluppo scaricato viene denominato aps_development.cer.
Fare doppio clic sul certificato push scaricato aps_development.cer. Questa azione installa il nuovo certificato nel Keychain, come illustrato nell'immagine seguente:

Annotazioni

Anche se il nome nel certificato potrebbe essere diverso, il nome sarà preceduto da Apple Development iOS Push Services.
In Accesso portachiavi fare clic con il pulsante destro del mouse sul nuovo certificato push creato nella categoria Certificati . Selezionare Export (Esporta), assegnare un nome al file, selezionare il formato .p12 e quindi selezionare Save (Salva).

È facoltativamente possibile scegliere di proteggere il certificato tramite una password. Fare clic su OK se si desidera ignorare la creazione della password. Prendere nota del nome del file e del percorso del certificato con estensione p12 esportato. Vengono usati per abilitare l'autenticazione con APN.

Annotazioni

Il nome e il percorso del file. P12 potrebbero essere diversi rispetto a quelli illustrati in questa esercitazione.

OPZIONE 2: Creazione di un certificato con estensione p8 che può essere usato per l'autenticazione basata su token

Prendere nota dei dettagli seguenti:
- App ID Prefix (Prefisso ID app); si tratta di un ID team
- Bundle ID
In Certificates, Identifiers & Profiles (Certificati, identificatori e profili) fare clic su Keys (Chiavi).

Annotazioni

Se è già stata configurata una chiave per APNS, è possibile riutilizzare il certificato con estensione .p8 scaricato subito dopo la creazione. In tal caso, è possibile ignorare i passaggi da 3 a 5.
Per creare una nuova chiave, fare clic sul pulsante + o sul pulsante Create a key (Crea una chiave).
Specificare un valore appropriato nome chiave , quindi selezionare l'opzione Apple Push Notifications service (APN) e quindi fare clic su Continua, quindi su Registra nella schermata successiva.
Fare clic su Scarica e quindi spostare il file con estensione p8 (preceduto da AuthKey_) in una directory locale sicura, quindi fare clic su Fine.

Annotazioni

Assicurarsi di conservare il file con estensione .p8 in un luogo sicuro e salvare un backup. Dopo aver scaricato la chiave, non è possibile scaricarla nuovamente perché la copia del server viene rimossa.
In Keys (Chiavi) fare clic sulla chiave appena creata (oppure su una chiave esistente se si è scelto di usare tale chiave).
Prendere nota del valore di Key ID (ID chiave).
Aprire il certificato con estensione p8 in un'applicazione appropriata a scelta, ad esempio Visual Studio Code , quindi prendere nota del valore della chiave. ovvero del valore compreso tra -----BEGIN PRIVATE KEY----- e -----END PRIVATE KEY-----.
```
-----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----
```
Annotazioni

Si tratta del valore del token che verrà usato in un secondo momento per configurare l'hub di notifica.

Al termine di questi passaggi è necessario avere le informazioni seguenti per usarle più avanti in Configurare l'hub di notifica con informazioni su APN:

Team ID (vedere il passaggio 1)
ID bundle (vedere il passaggio 1)
Key ID (ID chiave) (vedere il passaggio 7)
Valore del token , ad esempio il valore della chiave p8 (vedere il passaggio 8)

Creare un profilo di provisioning per l'applicazione

Tornare a iOS Provisioning Portal (Portale di provisioning di iOS), selezionare Certificates, Identifiers & Profiles (Certificati, identificatori e profili), quindi Profiles (Profili) dal menu a sinistra e infine selezionare + per creare un nuovo profilo. Verrà visualizzata la schermata Register a New Provisioning Profile (Registra un nuovo profilo di provisioning).
Selezionare iOS App Development sotto Development come tipo di profilo di provisioning e quindi selezionare Continua.
Selezionare quindi l'ID app creato dall'elenco a discesa ID app e selezionare Continua.
Nella finestra Select certificates (Seleziona certificati) selezionare il certificato di sviluppo usato per la firma del codice e quindi fare clic su Continue (Continua). Questo non è il certificato push creato. Se non ne esiste uno, è necessario crearlo. Se esiste un certificato, andare al passaggio successivo. Per creare un certificato di sviluppo, se non ne esiste uno:
1. Se viene visualizzato il messaggio No Certificates are available (Nessun certificato disponibile), selezionare Create Certificate (Crea certificato).
2. Nella sezione Software selezionare Apple Development (Sviluppo Apple). Selezionare quindi Continua.
3. Nella schermata Create a New Certificate (Crea un nuovo certificato) selezionare Choose File (Scegli file).
4. Passare al certificato Certificate Signing Request (Richiesta di firma del certificato) creato in precedenza, selezionarlo e quindi scegliere Open (Apri).
5. Seleziona Continua.
6. Scarica il certificato di sviluppo e ricorda il percorso in cui è stato salvato.
Tornare alla pagina Certificates, Identifiers & Profiles (Certificati, identificatori e profili), selezionare Profiles (Profili) dal menu a sinistra e infine selezionare + per creare un nuovo profilo. Verrà visualizzata la schermata Register a New Provisioning Profile (Registra un nuovo profilo di provisioning).
Nella finestra Select certificates (Seleziona certificati) selezionare il certificato di sviluppo appena creato. Selezionare quindi Continua.
Selezionare quindi i dispositivi da usare per il test e selezionare Continue (Continua).
Infine, scegliere un nome per il profilo nel campo Nome profilo di provisioning e selezionare Genera.
Quando viene creato il nuovo profilo di provisioning, selezionare Download. Ricorda la posizione in cui viene salvata.
Passare alla posizione del profilo di provisioning, quindi fare doppio clic su di esso per installarlo sul computer di sviluppo con Xcode.

Creare un hub di notifica

In questa sezione viene creato un hub di notifica e viene configurata l'autenticazione con APN usando il certificato push con estensione p12 o l'autenticazione basata su token. Se si vuole usare un hub di notifica che è già stato creato, è possibile ignorare il passaggio 5.

Accedere al portale di Azure.
Scegliere Tutti i servizi dal menu a sinistra e quindi selezionare Hub di notifica nella sezione Dispositivi mobili. Selezionare l'icona a forma di stella accanto al nome del servizio per aggiungere il servizio alla sezione PREFERITI nel menu a sinistra. Dopo aver aggiunto Hub di notifica a PREFERITI, selezionarlo nel menu a sinistra.
Nella pagina Hub di notifica selezionare Aggiungi sulla barra degli strumenti.
Nella pagina Hub di notifica seguire questa procedura:
1. Immettere un nome in Hub di notifica.
2. Immettere un nome in Crea un nuovo spazio dei nomi. Uno spazio dei nomi contiene uno o più hub.
3. Selezionare un valore nell'elenco a discesa Posizione. Questo valore specifica la posizione in cui creare l'hub.
4. Selezionare un gruppo di risorse esistente in Gruppo di risorse oppure creare un nome per un nuovo gruppo di risorse.
5. Fare clic su Crea.
Selezionare Notifiche (icona a forma di campanello) e quindi selezionare Vai alla risorsa. È anche possibile aggiornare l'elenco nella pagina Hub di notifica e selezionare l'hub.
Selezionare Criteri di accesso dall'elenco. Nota che le due stringhe di connessione sono disponibili per te. Sono necessarie in un secondo momento per gestire le notifiche push.

Importante

Non usare il criterio DefaultFullSharedAccessSignature nella tua applicazione. Deve essere utilizzato solo nella parte posteriore.

Configurare l'hub di notifica con informazioni su APN

In Servizi di notifica selezionare Apple (APNS) e quindi seguire i passaggi appropriati in base all'approccio scelto in precedenza nella sezione Creazione di un certificato per Hub di notifica .

Annotazioni

Usa la produzione per la modalità applicazione solo se vuoi inviare notifiche push agli utenti che hanno acquistato l'app dallo Store.

OPZIONE 1: Uso di un certificato push con estensione p12

Selezionare Certificate.
Selezionare l'icona del file.
Selezionare il file con estensione p12 esportato in precedenza e quindi selezionare Open (Apri).
Se necessario, specificare la password corretta.
Selezionare la modalità Sandbox.
Seleziona Salva.

OPZIONE 2: Uso dell'autenticazione basata su token

Selezionare Token.
Immettere i valori seguenti acquisiti in precedenza:
- Key ID (ID chiave)
- ID bundle
- Team ID
- Token
Scegliere Sandbox
Seleziona Salva.

Hai ora configurato il tuo hub di notifica con gli APN. Sono disponibili anche le stringhe di connessione per registrare l'app e inviare notifiche push.

Configurare l'hub di notifica per APNS

Sul tuo Mac, avvia Keychain Access. Nella barra di navigazione a sinistra, sotto Categoria, aprire I miei certificati. Trovare il certificato SSL scaricato nella sezione precedente e quindi divulgarne il contenuto. Selezionare solo il certificato (non selezionare la chiave privata). Quindi esportarlo.
Nel portale di Azure selezionare Esplora tutti i Servizi App>. Selezionare quindi il back-end delle app per dispositivi mobili.
In Impostazioni, selezionare Push del Servizio App. Selezionare quindi il nome dell'hub di notifica.
Passare a Apple Push Notification Services>Carica certificato. Caricare il file con estensione .p12, selezionando la modalità corretta (a seconda che il certificato client SSL ottenuto in precedenza sia di produzione o sandbox). Salvare eventuali modifiche.

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

Si configurerà quindi l'impostazione del progetto iOS in Xamarin Studio o Visual Studio.

Configurare il progetto iOS in Xamarin Studio

In Xamarin.Studio aprire Info.plist e aggiornare l'identificatore del bundle con l'ID bundle creato in precedenza con il nuovo ID app.
Scorrere verso il basso fino a Modalità di sfondo. Selezionare la casella Abilita modalità in background e la casella Notifiche remote .
Fare doppio clic sul progetto nel pannello della soluzione per aprire Opzioni progetto.
Nella sezione Compilazione, scegli Firma bundle iOS e seleziona l'identità e il profilo di provisioning corrispondenti che hai appena configurato per questo progetto.

In questo modo il progetto usa il nuovo profilo per la firma del codice. Per la documentazione ufficiale sul provisioning dei dispositivi Xamarin, vedere Provisioning di dispositivi Xamarin.

Configurare il progetto iOS in Visual Studio

In Visual Studio fare clic con il pulsante destro del mouse sul progetto e quindi scegliere Proprietà.
Nelle pagine delle proprietà fare clic sulla scheda Applicazione iOS e aggiornare l'identificatore con l'ID creato in precedenza.
Nella scheda Firma bundle iOS, selezionare l'identità corrispondente e il profilo di provisioning appena configurati per questo progetto.

In questo modo il progetto usa il nuovo profilo per la firma del codice. Per la documentazione ufficiale sul provisioning dei dispositivi Xamarin, vedere Provisioning di dispositivi Xamarin.
Fare doppio clic su Info.plist per aprirlo e quindi abilitare RemoteNotifications in Modalità in background.

Aggiungi notifiche push all'app iOS

Nel progetto iOS aprire AppDelegate.cs e aggiungere l'istruzione seguente all'inizio del file di codice.
```
using Newtonsoft.Json.Linq;
```

Nella classe AppDelegate aggiungere un override per l'evento RegisteredForRemoteNotifications per 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);
}

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'app è in esecuzione.

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

In questo modo è possibile supportare le notifiche remote e le richieste di registrazione push.

L'app è ora aggiornata per supportare le notifiche push.

Testare le notifiche push nell'app iOS

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

Annotazioni

È necessario accettare in modo esplicito le notifiche push dall'app. Questa richiesta viene eseguita solo la prima volta che l'app viene eseguita.
Nella app, inserisci un'attività, poi fai clic sull'icona del segno più (+).
Verificare che venga ricevuta una notifica e quindi fare clic su OK per ignorare la notifica.

Configurare ed eseguire progetti Windows (facoltativo)

Questa sezione riguarda l'esecuzione dei progetti WinApp Xamarin.Forms e WinPhone81 per i dispositivi Windows. Questi passaggi supportano anche progetti UWP (Universal Windows Platform). Se non si utilizzano dispositivi Windows, è possibile ignorare questa sezione.

Registrare l'app di Windows per le notifiche push con Windows Notification Service (WNS)

In Esplora Soluzioni di Visual Studio, fai clic con il pulsante destro del mouse sul progetto dell'app Windows Store. Seleziona quindi Store>associa l'app allo Store.
Nella procedura guidata selezionare Avanti. Accedere quindi con l'account Microsoft. In Riservare un nuovo nome per l'app, digita un nome per l'app e quindi seleziona Prenota.
Dopo aver creato la registrazione dell'app, selezionare il nuovo nome dell'app. Selezionare Avantie quindi selezionare Associa. Questo processo aggiunge le informazioni di registrazione di Windows Store necessarie al manifesto dell'applicazione.
Ripetere i passaggi 1 e 3 per il progetto di app di Windows Phone Store usando la stessa registrazione creata in precedenza per l'app di Windows Store.
Passare al Windows Dev Centere quindi accedere con l'account Microsoft. In App personaliselezionare la nuova registrazione dell'app. Espandere quindi Services>Notifiche push.
Nella pagina Notifiche push, sotto Servizi notifica push Windows (WNS) e Microsoft Azure Mobile Apps, selezionare il sito di Live Services. Prendere nota dei valori del SID del pacchetto e del valore corrente in segreto applicazione.

impostazioni dell'app

Importante

Il SID del segreto dell'applicazione e il SID del pacchetto sono credenziali di sicurezza importanti. Non condividere questi valori con nessuno o distribuirli con l'app.

Configurare l'hub di notifica per WNS

Nel portale di Azure selezionare Esplora tutti i Servizi App>. Selezionare quindi il back-end delle app per dispositivi mobili. In Impostazioni, selezionare Push del Servizio App. Selezionare quindi il nome dell'hub di notifica.
Passare a Windows (WNS). Immetti quindi la chiave di sicurezza (segreto client) e il SID pacchetto che hai ottenuto dal sito di Servizi Live. Selezionare quindi Salva.

Il back-end è ora configurato per l'uso di WNS per inviare notifiche push.

Aggiungere notifiche push all'app di Windows

In Visual Studio aprire 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 TodoItemManager classe .

In 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 di notifica push e registra un modello per ricevere notifiche basate su modelli dal tuo hub di notifica. A questo client verrà recapitata una notifica di modello che supporta messageParam .

In App.xaml.cs aggiornare la definizione del metodo del gestore eventi OnLaunched aggiungendo il async modificatore. Aggiungere quindi la riga di codice seguente alla fine del metodo :
```
await InitNotificationsAsync();
```
In questo modo si garantisce che la registrazione della notifica push venga creata o aggiornata ogni volta che viene avviata l'app. È importante eseguire questa operazione per garantire che il canale push WNS sia sempre attivo.
In Esplora Soluzioni per Visual Studio, apri il file Package.appxmanifest e imposta Toast Capable su Sì sotto Notifiche.
Compilare l'app e verificare che non siano presenti errori. L'app client dovrebbe ora registrarsi per le notifiche dei modelli dal back-end delle app per dispositivi mobili. Ripetere questa sezione per ogni progetto Windows nella soluzione.

Testare le notifiche push nell'app di Windows

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

Passaggi successivi

Per altre informazioni sulle notifiche push, vedere:

Invio di notifiche push da app per dispositivi mobili di Azure
Firebase Cloud Messaging
Notifiche remote con Firebase Cloud Messaging
Diagnosticare i problemi di notifica push
Esistono diversi motivi per cui le notifiche possono essere eliminate o non finiscono nei dispositivi. Questo argomento illustra come analizzare e individuare la causa radice degli errori di notifica push.

È anche possibile continuare con una delle esercitazioni seguenti:

Aggiungere l'autenticazione all'app
Informazioni su come autenticare gli utenti dell'app con un provider di identità.
Abilitare la sincronizzazione offline per l'app
Informazioni su come aggiungere il supporto offline per l'app usando un back-end di App per dispositivi mobili. Con la sincronizzazione offline, gli utenti possono interagire con un'app per dispositivi mobili, visualizzando, aggiungendo o modificando i dati, anche quando non è presente alcuna connessione di rete.

Last updated on 2019-06-25

Condividi tramite