Remote Notifications with Firebase Cloud Messaging (Notifiche remote con Firebase Cloud Messaging)

Questa procedura dettagliata fornisce una spiegazione dettagliata di come usare Firebase Cloud Messaging per implementare notifiche remote (denominate anche notifiche push) in un'applicazione Xamarin.Android. Illustra come implementare le varie classi necessarie per le comunicazioni con Firebase Cloud Messaging (FCM), fornisce esempi di come configurare il manifesto Android per l'accesso a FCM e illustra la messaggistica downstream usando la console firebase.

Panoramica delle notifiche FCM

In questa procedura dettagliata verrà creata un'app di base denominata FCMClient per illustrare le nozioni di base della messaggistica FCM. FCMClient verifica la presenza di Google Play Services, riceve i token di registrazione da FCM, visualizza le notifiche remote inviate dalla console firebase e sottoscrive i messaggi dell'argomento:

Screenshot di esempio dell'app.

Verranno esaminate le aree dell'argomento seguenti:

  1. Notifiche in background

  2. Messaggi di argomento

  3. Notifiche in primo piano

Durante questa procedura dettagliata si aggiungeranno in modo incrementale funzionalità a FCMClient e la si eseguirà in un dispositivo o un emulatore per comprendere come interagisce con FCM. Si userà la registrazione per controllare le transazioni di app in tempo reale con i server FCM e si osserverà come vengono generate le notifiche dai messaggi FCM immessi nell'interfaccia utente grafica di Firebase Console Notifications.

Requisiti

Sarà utile acquisire familiarità con i diversi tipi di messaggi che possono essere inviati da Firebase Cloud Messaging. Il payload del messaggio determinerà il modo in cui un'app client riceverà ed eelaborare il messaggio.

Prima di procedere con questa procedura dettagliata, è necessario acquisire le credenziali necessarie per usare i server FCM di Google. Questo processo è illustrato in Firebase Cloud Messaging. In particolare, è necessario scaricare il google-services.jsfile da usare con il codice di esempio presentato in questa procedura dettagliata. Se non è ancora stato creato un progetto nella console di Firebase (o se non è ancora stato scaricato ilgoogle-services.jssu file), vedere Firebase Cloud Messaging.

Per eseguire l'app di esempio, è necessario un dispositivo di test Android o un emulatore compatibile con Firebase. Firebase Cloud Messaging supporta i client in esecuzione in Android 4.0 o versione successiva e per questi dispositivi deve essere installata anche l'app Google Play Store (è necessario Google Play Services 9.2.1 o versione successiva). Se l'app Google Play Store installata nel dispositivo non è ancora installata, visitare il sito Web Google Play per scaricarla e installarla. In alternativa, è possibile usare l'emulatore Android SDK con Google Play Services installato anziché un dispositivo di test (non è necessario installare il Google Play Store se si usa l'emulatore Android SDK).

Avviare un progetto di app

Per iniziare, creare un nuovo progetto Xamarin.Android vuoto denominato FCMClient. Se non si ha familiarità con la creazione di progetti Xamarin.Android, vedere Hello, Android. Dopo aver creato la nuova app, il passaggio successivo consiste nell'impostare il nome del pacchetto e installare diversi pacchetti NuGet che verranno usati per la comunicazione con FCM.

Impostare il nome del pacchetto

In Firebase Cloud Messagingè stato specificato un nome di pacchetto per l'app abilitata per FCM. Questo nome di pacchetto funge anche da ID applicazione associato alla chiave API. Configurare l'app per l'uso del nome del pacchetto:

  1. Aprire le proprietà per il progetto FCMClient.

  2. Nella pagina Manifesto Android impostare il nome del pacchetto.

Nell'esempio seguente il nome del pacchetto è impostato su com.xamarin.fcmexample :

Impostazione del nome del pacchetto.

Durante l'aggiornamento del manifesto Android, verificare anche che l'autorizzazione Internet sia abilitata.

Importante

L'app client non sarà in grado di ricevere un token di registrazione da FCM se il nome del pacchetto non corrisponde esattamente al nome del pacchetto immesso nella console firebase.

Aggiungere il pacchetto Xamarin Google Play Services Base

Poiché Firebase Cloud Messaging dipende Google Play Services, il pacchetto Xamarin Google Play Services - Base NuGet deve essere aggiunto al progetto Xamarin.Android. È necessaria la versione 29.0.0.2 o successiva.

  1. In Visual Studio fare clic con il pulsante destro del mouse su Riferimenti > Gestisci NuGet pacchetti ....

  2. Fare clic sulla scheda Sfoglia e cercare Xamarin.GooglePlayServices.Base.

  3. Installare questo pacchetto nel progetto FCMClient:

    Installazione di Google Play Services Base.

Se si verifica un errore durante l'installazione del NuGet, chiudere il progetto FCMClient, aprirlo di nuovo e ripetere l NuGet installazione.

Quando si installa Xamarin.GooglePlayServices.Base, vengono installate anche tutte le dipendenze necessarie. Modificare MainActivity.cs e aggiungere l'istruzione using seguente:

using Android.Gms.Common;

Questa istruzione rende la GoogleApiAvailability classe in Xamarin.GooglePlayServices.Base disponibile per il codice FCMClient. GoogleApiAvailability viene usato per verificare la presenza di Google Play Services.

Aggiungere il pacchetto di messaggistica Xamarin Firebase

Per ricevere messaggi da FCM, è necessario aggiungere il pacchetto NuGet di messaggistica Xamarin Firebase al progetto di app. Senza questo pacchetto, un'applicazione Android non può ricevere messaggi dai server FCM.

  1. In Visual Studio fare clic con il pulsante destro del mouse su Riferimenti > Gestisci NuGet pacchetti ....

  2. Cercare Xamarin.Firebase.Messaging.

  3. Installare questo pacchetto nel progetto FCMClient:

    Installazione di Xamarin Firebase Messaging.

Quando si installa Xamarin.Firebase.Messaging, vengono installate anche tutte le dipendenze necessarie.

Modificare quindi MainActivity.cs e aggiungere le using istruzioni seguenti:

using Firebase.Messaging;
using Firebase.Iid;
using Android.Util;

Le prime due istruzioni rendono i tipi nel pacchetto di NuGet Xamarin.Firebase.Messaging disponibili per il codice FCMClient. Android.Util aggiunge funzionalità di registrazione che verranno usate per osservare le transazioni con FMS.

Aggiungere il file JSON di Google Services

Il passaggio successivo consiste nell'aggiungeregoogle-services.jsnel file alla directory radice del progetto:

  1. Copiare google-services.jsnella cartella del progetto.

  2. Aggiungere google-services.js al progetto di app (fare clic su Mostra tutti i file nel Esplora soluzioni, fare clic con il pulsante destro del mouse su google-services.js in , quindi selezionare Includi in Project ).

  3. Selezionare google-services.json nella finestra Esplora soluzioni.

  4. Nel riquadro Proprietà impostare Azione di compilazione su GoogleServicesJson:

    Impostazione dell'azione di compilazione su GoogleServicesJson.

    Nota

    Se l'azione di compilazione GoogleServicesJson non viene visualizzata, salvare e chiudere la soluzione, quindi riaprirla.

Quando google-services.js on viene aggiunto al progetto (ed è impostata l'azione di compilazione GoogleServicesJson), il processo di compilazione estrae l'ID client e la chiave API e quindi aggiunge queste credenziali alAndroidManifest.xmlunito/generato che si trova in obj/Debug/android/AndroidManifest.xml. Questo processo di unione aggiunge automaticamente tutte le autorizzazioni e altri elementi FCM necessari per la connessione ai server FCM.

Verificare la presenza Google Play Services e creare un canale di notifica

Google consiglia alle app Android di verificare la presenza del file APK di Google Play Services prima di accedere alle funzionalità di Google Play Services. Per altre informazioni, vedere Verificare la disponibilità di Google Play servizi.

Verrà creato per primo un layout iniziale per l'interfaccia utente dell'app. Modificare Resources/layout/Main.axml e sostituirne il contenuto con il codice XML seguente:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="10dp">
    <TextView
        android:text=" "
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/msgText"
        android:textAppearance="?android:attr/textAppearanceMedium"
        android:padding="10dp" />
</LinearLayout>

Verrà TextView utilizzato per visualizzare i messaggi che indicano se Google Play Services è installato. Salvare le modifiche apportate a Main.axml.

Modificare MainActivity.cs e aggiungere le variabili di istanza seguenti alla MainActivity classe :

public class MainActivity : AppCompatActivity
{
    static readonly string TAG = "MainActivity";

    internal static readonly string CHANNEL_ID = "my_notification_channel";
    internal static readonly int NOTIFICATION_ID = 100;

    TextView msgText;

Le variabili CHANNEL_ID e verranno usate nel metodo che verrà aggiunto a più avanti in questa procedura NOTIFICATION_ID CreateNotificationChannel MainActivity dettagliata.

Nell'esempio seguente il metodo verificherà che il Google Play Services sia disponibile prima che OnCreate l'app tenti di usare i servizi FCM. Aggiungere il metodo seguente alla classe MainActivity:

public bool IsPlayServicesAvailable ()
{
    int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable (this);
    if (resultCode != ConnectionResult.Success)
    {
        if (GoogleApiAvailability.Instance.IsUserResolvableError (resultCode))
            msgText.Text = GoogleApiAvailability.Instance.GetErrorString (resultCode);
        else
        {
            msgText.Text = "This device is not supported";
            Finish ();
        }
        return false;
    }
    else
    {
        msgText.Text = "Google Play Services is available.";
        return true;
    }
}

Questo codice controlla il dispositivo per verificare se il Google Play Services'APK è installato. Se non è installato, viene visualizzato un messaggio in che indica all'utente di scaricare un APK dal Google Play Store (o di abilitarlo nelle impostazioni di sistema del TextBox dispositivo).

Le app in esecuzione in Android 8.0 (livello API 26) o versione successiva devono creare un canale di notifica per la pubblicazione delle notifiche. Aggiungere il metodo seguente alla MainActivity classe che creerà il canale di notifica (se necessario):

void CreateNotificationChannel()
{
    if (Build.VERSION.SdkInt < BuildVersionCodes.O)
    {
        // Notification channels are new in API 26 (and not a part of the
        // support library). There is no need to create a notification
        // channel on older versions of Android.
        return;
    }

    var channel = new NotificationChannel(CHANNEL_ID,
                                          "FCM Notifications",
                                          NotificationImportance.Default)
                  {

                      Description = "Firebase Cloud Messages appear in this channel"
                  };

    var notificationManager = (NotificationManager)GetSystemService(Android.Content.Context.NotificationService);
    notificationManager.CreateNotificationChannel(channel);
}

Sostituire il metodo OnCreate con il codice seguente:

protected override void OnCreate (Bundle bundle)
{
    base.OnCreate (bundle);
    SetContentView (Resource.Layout.Main);
    msgText = FindViewById<TextView> (Resource.Id.msgText);

    IsPlayServicesAvailable ();

    CreateNotificationChannel();
}

IsPlayServicesAvailable viene chiamato alla fine di in OnCreate modo che il Google Play Services controllo venga eseguito a ogni avvio dell'app. Il metodo CreateNotificationChannel viene chiamato per assicurarsi che esista un canale di notifica per i dispositivi che eseguono Android 8 o versione successiva. Se l'app ha OnResume un metodo , deve chiamare anche da IsPlayServicesAvailable OnResume . Ricompilare ed eseguire completamente l'app. Se tutte le impostazioni sono configurate correttamente, verrà visualizzata una schermata simile alla schermata seguente:

L'app indica Google Play Services è disponibile.

Se non si ottiene questo risultato, verificare che l'APK di Google Play Services sia installato nel dispositivo. Per altre informazioni, vedere Configurazione di Google Play Services. Verificare anche di aver aggiunto il pacchetto Xamarin.Google.Play.Services.Base al progetto FCMClient, come illustrato in precedenza.

Aggiungere il ricevitore dell'ID istanza

Il passaggio successivo consiste nell'aggiungere un servizio che si estende per gestire la creazione, la rotazione e l'aggiornamento FirebaseInstanceIdService dei token di registrazione firebase. Il FirebaseInstanceIdService servizio è necessario perché FCM sia in grado di inviare messaggi al dispositivo. Quando il servizio viene aggiunto all'app client, l'app riceverà automaticamente i messaggi FCM e li visualizza come notifiche ogni volta che FirebaseInstanceIdService l'app viene eseguita in background.

Dichiarare il ricevitore nel manifesto Android

Modificare AndroidManifest.xml e inserire gli elementi <receiver> seguenti nella sezione <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>

Questo codice XML esegue le operazioni seguenti:

  • Dichiara un'implementazione FirebaseInstanceIdReceiver che fornisce un identificatore univoco per ogni istanza dell'app. Questo ricevitore autentica e autorizza anche le azioni.

  • Dichiara un'implementazione FirebaseInstanceIdInternalReceiver interna utilizzata per avviare i servizi in modo sicuro.

  • L'ID app viene archiviato nelgoogle-services.jsnel file aggiunto al progetto. Le associazioni Firebase Xamarin.Android sostituiranno il token con l'ID app. Non è necessario codice aggiuntivo per l'app client per fornire ${applicationId} l'ID app.

è FirebaseInstanceIdReceiver un oggetto che riceve gli eventi e e li WakefulBroadcastReceiver recapita alla classe derivata da FirebaseInstanceId FirebaseMessaging FirebaseInstanceIdService .

Implementare il servizio ID istanza firebase

Il lavoro di registrazione dell'applicazione con FCM viene gestito dal FirebaseInstanceIdService servizio personalizzato fornito. FirebaseInstanceIdService esegue i passaggi seguenti:

  1. Usa l'API ID istanza per generare token di sicurezza che autorizzano l'app client ad accedere a FCM e al server app. In cambio, l'app ottiene un token di registrazione da FCM.

  2. Inoltra il token di registrazione al server app, se richiesto dal server applicazioni.

Aggiungere un nuovo file denominato MyFirebaseIIDService.cs e sostituire il codice del modello con il codice seguente:

using System;
using Android.App;
using Firebase.Iid;
using Android.Util;

namespace FCMClient
{
    [Service]
    [IntentFilter(new[] { "com.google.firebase.INSTANCE_ID_EVENT" })]
    public class MyFirebaseIIDService : FirebaseInstanceIdService
    {
        const string TAG = "MyFirebaseIIDService";
        public override void OnTokenRefresh()
        {
            var refreshedToken = FirebaseInstanceId.Instance.Token;
            Log.Debug(TAG, "Refreshed token: " + refreshedToken);
            SendRegistrationToServer(refreshedToken);
        }
        void SendRegistrationToServer(string token)
        {
            // Add custom implementation, as needed.
        }
    }
}

Questo servizio implementa un OnTokenRefresh metodo che viene richiamato quando il token di registrazione viene inizialmente creato o modificato. Quando OnTokenRefresh viene eseguito, recupera il token più recente dalla FirebaseInstanceId.Instance.Token proprietà , che viene aggiornata in modo asincrono da FCM. In questo esempio, il token aggiornato viene registrato in modo che possa essere visualizzato nella finestra di output:

var refreshedToken = FirebaseInstanceId.Instance.Token;
Log.Debug(TAG, "Refreshed token: " + refreshedToken);

OnTokenRefresh viene richiamato raramente: viene usato per aggiornare il token nelle circostanze seguenti:

  • Quando l'app viene installata o disinstallata.

  • Quando l'utente elimina i dati dell'app.

  • Quando l'app cancella l'ID istanza.

  • Quando la sicurezza del token è stata compromessa.

In base alla documentazione dell'ID istanza di Google, il servizio ID istanza FCM richiederà all'app di aggiornare periodicamente il token (in genere ogni 6 mesi).

OnTokenRefresh chiama anche per associare il token di registrazione SendRegistrationToAppServer dell'utente all'account lato server (se presente) gestito dall'applicazione:

void SendRegistrationToAppServer (string token)
{
    // Add custom implementation here as needed.
}

Poiché questa implementazione dipende dalla progettazione del server app, in questo esempio viene fornito un corpo del metodo vuoto. Se il server app richiede informazioni di registrazione FCM, modificare per associare il token ID istanza FCM dell'utente a qualsiasi SendRegistrationToAppServer account lato server gestito dall'app. Si noti che il token è opaco per l'app client.

Quando un token viene inviato al server app, deve mantenere un valore booleano per indicare se SendRegistrationToAppServer il token è stato inviato al server. Se questo valore booleano è false, invia il token al server app; in caso contrario, il token è già stato inviato al server app SendRegistrationToAppServer – in una chiamata precedente. In alcuni casi, ad esempio in questo esempio, il server app non richiede il token, pertanto questo metodo non FCMClient è necessario per questo esempio.

Implementare il codice dell'app client

Ora che i servizi ricevitore sono disponibili, è possibile scrivere il codice dell'app client per sfruttare i vantaggi di questi servizi. Nelle sezioni seguenti viene aggiunto un pulsante all'interfaccia utente per registrare il token di registrazione (detto anche token ID istanza) e viene aggiunto altro codice a per visualizzare le informazioni quando l'app viene avviata da una MainActivity Intent notifica:

Pulsante Token di log aggiunto alla schermata dell'app.

Token di log

Il codice aggiunto in questo passaggio è destinato solo a scopi dimostrativi e non è necessario che un'app client di produzione registri – i token di registrazione. Modificare Resources/layout/Main.axml e aggiungere la dichiarazione Button seguente immediatamente dopo l'elemento TextView :

<Button
  android:id="@+id/logTokenButton"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:layout_gravity="center_horizontal"
  android:text="Log Token" />

Aggiungere il codice seguente alla fine del metodo MainActivity.OnCreate:

var logTokenButton = FindViewById<Button>(Resource.Id.logTokenButton);
logTokenButton.Click += delegate {
    Log.Debug(TAG, "InstanceID token: " + FirebaseInstanceId.Instance.Token);
};

Questo codice registra il token corrente nella finestra di output quando viene toccato il pulsante Token di log.

Gestire le finalità di notifica

Quando l'utente tocca una notifica emessa da FCMClient, tutti i dati che accompagnano il messaggio di notifica vengono resi disponibili in Intent più. Modificare MainActivity.cs e aggiungere il codice seguente all'inizio del OnCreate metodo (prima della chiamata a IsPlayServicesAvailable ):

if (Intent.Extras != null)
{
    foreach (var key in Intent.Extras.KeySet())
    {
        var value = Intent.Extras.GetString(key);
        Log.Debug(TAG, "Key: {0} Value: {1}", key, value);
    }
}

L'utilità di avvio dell'app viene attivata quando l'utente tocca il messaggio di notifica, quindi questo codice registra tutti i dati relativi Intent in nella finestra di Intent output. Se deve essere attivato un oggetto diverso, il campo del messaggio di notifica deve essere impostato su tale valore (l'utilità di avvio viene usata Intent quando non è specificato alcun click_action Intent Intent click_action valore).

Notifiche in background

Compilare ed eseguire l'app FCMClient. Viene visualizzato il pulsante Token di log:

Viene visualizzato il pulsante Token di log.

Toccare il pulsante Token di log. Nella finestra di output dell'IDE dovrebbe essere visualizzato un messaggio simile al seguente:

Token ID istanza visualizzato nella finestra Output.

La stringa lunga etichettata con token è il token ID dell'istanza che verrà incollato nella selezione della console Firebase e la copia – negli Appunti. Se non viene visualizzato un token ID istanza, aggiungere la riga seguente all'inizio del metodo per verificare chegoogle-services.jsOnCreate in sia stato analizzato correttamente:

Log.Debug(TAG, "google app id: " + GetString(Resource.String.google_app_id));

Il valore registrato nella finestra di output deve corrispondere al valore registrato ingoogle-services.jsgoogle_app_id mobilesdk_app_id in. Resource.String.google_app_idL'oggetto viene generato da msbuild durante l'elaborazionegoogle-services.js in.

Inviare un messaggio

Accedere alla console di Firebase,selezionare il progetto, fare clic su Notifications (Notifiche) e quindi su SEND YOUR FIRST MESSAGE (INVIA IL PRIMO MESSAGGIO):

Pulsante Send Your First Message (Invia il primo messaggio).

Nella pagina Componi messaggio immettere il testo del messaggio e selezionare Dispositivo singolo. Copiare il token ID istanza dalla finestra di output dell'IDE e incollarlo nel campo del token di registrazione FCM della console firebase:

Finestra di dialogo Componi messaggio.

Nel dispositivo Android (o nell'emulatore) eseguire lo sfondo dell'app toccando il pulsante Panoramica di Android e toccando la schermata iniziale. Quando il dispositivo è pronto, fare clic su SEND MESSAGE (INVIA MESSAGGIO) nella console di Firebase:

Pulsante Invia messaggio.

Quando viene visualizzata la finestra di dialogo Rivedi messaggio, fare clic su INVIA. L'icona di notifica dovrebbe essere visualizzata nell'area di notifica del dispositivo (o dell'emulatore):

Viene visualizzata l'icona di notifica.

Aprire l'icona di notifica per visualizzare il messaggio. Il messaggio di notifica deve essere esattamente quello digitato nel campo di testo Message (Messaggio) della console firebase:

Nel dispositivo viene visualizzato un messaggio di notifica.

Toccare l'icona di notifica per avviare l'app FCMClient. I Intent dati aggiuntivi inviati a FCMClient sono elencati nella finestra di output dell'IDE:

Elenchi di elementi aggiuntivi della finalità da chiave, ID messaggio e chiave di compressione.

In questo esempio, la chiave from è impostata sul numero di progetto Firebase dell'app (in questo esempio, ) e il collapse_key è impostato sul nome del pacchetto 41590732 (com.xamarin.fcmexample). Se non si riceve un messaggio, provare a eliminare l'app FCMClient nel dispositivo (o nell'emulatore) e ripetere i passaggi precedenti.

Nota

Se si chiude forzatamente l'app, FCM interromperà il recapito delle notifiche. Android impedisce alle trasmissioni del servizio in background di avviare inavvertitamente o inutilmente componenti di applicazioni arrestate. Per altre informazioni su questo comportamento, vedere Avviare controlli nelle applicazioni arrestate. Per questo motivo, è necessario disinstallare manualmente l'app ogni volta che viene eseguita e arrestarla da una sessione di debug, in modo che FCM generi un nuovo token in modo che i messaggi continuino a essere – ricevuti.

Aggiungere un'icona di notifica predefinita personalizzata

Nell'esempio precedente l'icona di notifica è impostata sull'icona dell'applicazione. Il codice XML seguente configura un'icona predefinita personalizzata per le notifiche. Android visualizza questa icona predefinita personalizzata per tutti i messaggi di notifica in cui l'icona di notifica non è impostata in modo esplicito.

Per aggiungere un'icona di notifica predefinita personalizzata, aggiungere l'icona alla directory Resources/drawable, modificare AndroidManifest.xmle inserire l'elemento <meta-data> seguente nella sezione <application> :

<meta-data
    android:name="com.google.firebase.messaging.default_notification_icon"
    android:resource="@drawable/ic_stat_ic_notification" />

In questo esempio l'icona di notifica che si trova in Resources/drawable/ic _ stat _ icnotification.png_ verrà usata come icona di notifica predefinita personalizzata. Se un'icona predefinita personalizzata non è configurata in AndroidManifest.xml e non è impostata alcuna icona nel payload della notifica, Android usa l'icona dell'applicazione come icona di notifica (come illustrato nello screenshot dell'icona di notifica precedente).

Gestire i messaggi degli argomenti

Il codice scritto finora gestisce i token di registrazione e aggiunge funzionalità di notifica remota all'app. L'esempio successivo aggiunge codice che rimane in ascolto dei messaggi di argomento e li inoltra all'utente come notifiche remote. I messaggi di argomento sono messaggi FCM inviati a uno o più dispositivi che sottoscriveno un argomento specifico. Per altre informazioni sui messaggi di argomento, vedere Messaggistica degli argomenti.

Sottoscrivere un argomento

Modificare Resources/layout/Main.axml e aggiungere la dichiarazione Button seguente immediatamente dopo l'elemento Button precedente:

<Button
  android:id="@+id/subscribeButton"
  android:layout_width="match_parent"
  android:layout_height="wrap_content"
  android:layout_gravity="center_horizontal"
  android:layout_marginTop="20dp"
  android:text="Subscribe to Notifications" />

Questo codice XML aggiunge un pulsante Sottoscrivi alla notifica al layout. Modificare MainActivity.cs e aggiungere il codice seguente alla fine del OnCreate metodo :

var subscribeButton = FindViewById<Button>(Resource.Id.subscribeButton);
subscribeButton.Click += delegate {
    FirebaseMessaging.Instance.SubscribeToTopic("news");
    Log.Debug(TAG, "Subscribed to remote notifications");
};

Questo codice individua il pulsante Sottoscrivi notifica nel layout e assegna il gestore di clic al codice che chiama , passando l'argomento sottoscritto, FirebaseMessaging.Instance.SubscribeToTopic news. Quando l'utente tocca il pulsante Sottoscrivi, l'app sottoscrive l'argomento delle notizie. Nella sezione seguente verrà inviato un messaggio di argomento di notizie dall'interfaccia utente grafica delle notifiche della console di Firebase.

Inviare un messaggio di argomento

Disinstallare l'app, ricompilarla ed eseguirla di nuovo. Fare clic sul pulsante Sottoscrivi notifiche:

Pulsante Sottoscrivi notifiche.

Se l'app è stata sottoscritta correttamente, nella finestra di output dell'IDE dovrebbe essere visualizzato l'argomento sync succeeded (Sincronizzazione degli argomenti completata):

La finestra di output mostra il messaggio di sincronizzazione degli argomenti completata.

Per inviare un messaggio di argomento, seguire questa procedura:

  1. Nella console firebase fare clic su NUOVO MESSAGGIO.

  2. Nella pagina Componi messaggio immettere il testo del messaggio e selezionare Argomento.

  3. Nel menu a discesa Argomento selezionare l'argomento incorporato Notizie:

    Selezione dell'argomento notizie.

  4. Nel dispositivo Android (o emulatore) eseguire lo sfondo dell'app toccando il pulsante Panoramica di Android e toccando la schermata iniziale.

  5. Quando il dispositivo è pronto, fare clic su SEND MESSAGE (INVIA MESSAGGIO) nella console firebase.

  6. Controllare la finestra di output dell'IDE per visualizzare /topics/news nell'output del log:

    Viene visualizzato il messaggio da /topic/news.

Quando questo messaggio viene visualizzato nella finestra di output, l'icona di notifica dovrebbe essere visualizzata anche nell'area di notifica del dispositivo Android. Aprire l'icona di notifica per visualizzare il messaggio dell'argomento:

Il messaggio dell'argomento viene visualizzato come notifica.

Se non si riceve un messaggio, provare a eliminare l'app FCMClient nel dispositivo (o nell'emulatore) e ripetere i passaggi precedenti.

Notifiche in primo piano

Per ricevere notifiche nelle app in primo piano, è necessario implementare FirebaseMessagingService . Questo servizio è necessario anche per la ricezione di payload dei dati e per l'invio di messaggi upstream. Gli esempi seguenti illustrano come implementare un servizio che estende l'app risultante sarà in grado di gestire le notifiche remote mentre è FirebaseMessagingService – in esecuzione in primo piano.

Implementare FirebaseMessagingService

Il FirebaseMessagingService servizio è responsabile della ricezione e dell'elaborazione dei messaggi da Firebase. Ogni app deve sottoclassare questo tipo ed eseguire l'override OnMessageReceived di per elaborare un messaggio in ingresso. Quando un'app è in primo piano, il OnMessageReceived callback gestirà sempre il messaggio.

Nota

Le app hanno solo 10 secondi per gestire un messaggio cloud Firebase in ingresso. Qualsiasi lavoro che richiede più tempo di questo deve essere pianificato per l'esecuzione in background usando una libreria come Android Job Scheduler o Firebase Job Dispatcher.

Aggiungere un nuovo file denominato MyFirebaseMessagingService.cs e sostituire il codice del modello con il codice seguente:

using System;
using Android.App;
using Android.Content;
using Android.Media;
using Android.Util;
using Firebase.Messaging;

namespace FCMClient
{
    [Service]
    [IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
    public class MyFirebaseMessagingService : FirebaseMessagingService
    {
        const string TAG = "MyFirebaseMsgService";
        public override void OnMessageReceived(RemoteMessage message)
        {
            Log.Debug(TAG, "From: " + message.From);
            Log.Debug(TAG, "Notification Message Body: " + message.GetNotification().Body);
        }
    }
}

Si noti che MESSAGING_EVENT il filtro finalità deve essere dichiarato in modo che i nuovi messaggi FCM siano indirizzati a MyFirebaseMessagingService :

[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]

Quando l'app client riceve un messaggio da FCM, estrae il contenuto del messaggio dall'oggetto passato OnMessageReceived chiamando il relativo metodo RemoteMessage GetNotification . Registra quindi il contenuto del messaggio in modo che possa essere visualizzato nella finestra di output dell'IDE:

var body = message.GetNotification().Body;
Log.Debug(TAG, "Notification Message Body: " + body);

Nota

Se si impostano punti di interruzione in , la sessione di debug potrebbe o meno raggiunto questi punti di interruzione a causa del modo in cui FirebaseMessagingService FCM recapita i messaggi.

Inviare un altro messaggio

Disinstallare l'app, ricompilarla, eseguirla di nuovo e seguire questa procedura per inviare un altro messaggio:

  1. Nella console firebase fare clic su NUOVO MESSAGGIO.

  2. Nella pagina Compose message (Componi messaggio) immettere il testo del messaggio e selezionare Single device (Dispositivo singolo).

  3. Copiare la stringa del token dalla finestra di output IDE e incollarla nel campo del token di registrazione FCM della console firebase come prima.

  4. Assicurarsi che l'app sia in esecuzione in primo piano, quindi fare clic su SEND MESSAGE (INVIA MESSAGGIO) nella console firebase:

    Invio di un altro messaggio dalla console.

  5. Quando viene visualizzata la finestra di dialogo Rivedi messaggio, fare clic su INVIA.

  6. Il messaggio in ingresso viene registrato nella finestra di output dell'IDE:

    Corpo del messaggio stampato nella finestra di output.

Aggiungere un mittente di notifica locale

In questo esempio rimanente, il messaggio FCM in ingresso verrà convertito in una notifica locale avviata mentre l'app è in esecuzione in primo piano. Modificare MyFirebaseMessageService.cs e aggiungere le using istruzioni seguenti:

using FCMClient;
using System.Collections.Generic;

Aggiungere il metodo seguente a MyFirebaseMessagingService:

void SendNotification(string messageBody, IDictionary<string, string> data)
{
    var intent = new Intent(this, typeof(MainActivity));
    intent.AddFlags(ActivityFlags.ClearTop);
    foreach (var key in data.Keys)
    {
        intent.PutExtra(key, data[key]);
    }

    var pendingIntent = PendingIntent.GetActivity(this,
                                                  MainActivity.NOTIFICATION_ID,
                                                  intent,
                                                  PendingIntentFlags.OneShot);

    var notificationBuilder = new  NotificationCompat.Builder(this, MainActivity.CHANNEL_ID)
                              .SetSmallIcon(Resource.Drawable.ic_stat_ic_notification)
                              .SetContentTitle("FCM Message")
                              .SetContentText(messageBody)
                              .SetAutoCancel(true)
                              .SetContentIntent(pendingIntent);

    var notificationManager = NotificationManagerCompat.From(this);
    notificationManager.Notify(MainActivity.NOTIFICATION_ID, notificationBuilder.Build());
}

Per distinguere questa notifica dalle notifiche in background, questo codice contrassegna le notifiche con un'icona diversa dall'icona dell'applicazione. Aggiungere il file ic _ stat _ icnotification.png_ risorse/disegnabili e includerlo nel progetto FCMClient.

Il SendNotification metodo usa per creare la notifica e viene usato per avviare la NotificationCompat.Builder NotificationManagerCompat notifica. La notifica contiene un PendingIntent oggetto che consentirà all'utente di aprire l'app e visualizzare il contenuto della stringa passata in messageBody . Per altre informazioni su NotificationCompat.Builder , vedere Notifiche locali.

Chiamare il SendNotification metodo alla fine del metodo OnMessageReceived :

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

    var body = message.GetNotification().Body;
    Log.Debug(TAG, "Notification Message Body: " + body);
    SendNotification(body, message.Data);
}

Come risultato di queste modifiche, verrà eseguito ogni volta che viene ricevuta una notifica mentre l'app è in primo piano e la notifica verrà visualizzata SendNotification nell'area di notifica.

Quando un'app è in background, il payload del messaggio determinerà la modalità di gestione del messaggio:

  • Notifica – I messaggi verranno inviati alla barra delle applicazioni. Verrà visualizzata una notifica locale. Quando l'utente tocca la notifica, l'app verrà avviata.
  • Dati – i messaggi verranno gestiti da OnMessageReceived .
  • Entrambi – I messaggi con una notifica e un payload dei dati verranno recapitati nell'area di notifica. All'avvio dell'app, il payload dei dati verrà visualizzato in Extras dell'oggetto usato per avviare Intent l'app.

In questo esempio, se l'app è in background, SendNotification verrà eseguita se il messaggio ha un payload di dati. In caso contrario, verrà avviata una notifica in background (illustrata in precedenza in questa procedura dettagliata).

Inviare l'ultimo messaggio

Disinstallare l'app, ricompilarla, eseguirla di nuovo, quindi seguire questa procedura per inviare l'ultimo messaggio:

  1. Nella console firebase fare clic su NUOVO MESSAGGIO.

  2. Nella pagina Compose message (Componi messaggio) immettere il testo del messaggio e selezionare Single device (Dispositivo singolo).

  3. Copiare la stringa del token dalla finestra di output IDE e incollarla nel campo del token di registrazione FCM della console firebase come prima.

  4. Assicurarsi che l'app sia in esecuzione in primo piano, quindi fare clic su SEND MESSAGE (INVIA MESSAGGIO) nella console firebase:

    Invio del messaggio in primo piano.

Questa volta, anche il messaggio registrato nella finestra di output viene in pacchetto in una nuova notifica in cui viene visualizzata l'icona di notifica nella barra delle notifiche mentre l'app è – in esecuzione in primo piano:

Icona di notifica per il messaggio in primo piano.

Quando si apre la notifica, verrà visualizzato l'ultimo messaggio inviato dall'interfaccia utente grafica delle notifiche della console di Firebase:

Notifica in primo piano visualizzata con l'icona in primo piano.

Disconnessione da FCM

Per annullare la sottoscrizione di un argomento, chiamare il metodo UnsubscribeFromTopic sulla classe FirebaseMessaging. Ad esempio, per annullare la sottoscrizione all'argomento di notizie sottoscritto in precedenza, è possibile aggiungere un pulsante Annulla sottoscrizione al layout con il codice del gestore seguente:

var unSubscribeButton = FindViewById<Button>(Resource.Id.unsubscribeButton);
unSubscribeButton.Click += delegate {
    FirebaseMessaging.Instance.UnsubscribeFromTopic("news");
    Log.Debug(TAG, "Unsubscribed from remote notifications");
};

Per annullare completamente la registrazione del dispositivo da FCM, eliminare l'ID istanza chiamando il metodo DeleteInstanceId nella classe FirebaseInstanceId. Ad esempio:

FirebaseInstanceId.Instance.DeleteInstanceId();

Questa chiamata al metodo elimina l'ID istanza e i dati associati. Di conseguenza, l'invio periodico di dati FCM al dispositivo viene interrotto.

Risoluzione dei problemi

Di seguito vengono descritti i problemi e le soluzioni alternative che possono verificarsi quando si usa Firebase Cloud Messaging con Xamarin.Android.

FirebaseApp non è inizializzato

In alcuni casi, è possibile che venga visualizzato questo messaggio di errore:

Java.Lang.IllegalStateException: Default FirebaseApp is not initialized in this process
Make sure to call FirebaseApp.initializeApp(Context) first.

Si tratta di un problema noto che è possibile risolvere pulendo la soluzione e ricompilando il progetto ( Build > Clean Solution, Build > Rebuild Solution).

Riepilogo

Questa procedura dettagliata illustra in dettaglio i passaggi per l'implementazione delle notifiche remote di Firebase Cloud Messaging in un'applicazione Xamarin.Android. È stato descritto come installare i pacchetti necessari per le comunicazioni FCM e come configurare il manifesto Android per l'accesso ai server FCM. È stato fornito un codice di esempio che illustra come verificare la presenza di Google Play Services. Ha illustrato come implementare un servizio listener id istanza che negozia con FCM per un token di registrazione e come questo codice crea notifiche in background mentre l'app è in background. Ha spiegato come sottoscrivere messaggi di argomento e ha fornito un'implementazione di esempio di un servizio listener di messaggi usato per ricevere e visualizzare notifiche remote mentre l'app è in esecuzione in primo piano.