Esercitazione: Inviare notifiche push ai dispositivi Android con Google Firebase Cloud MessagingTutorial: Send push notifications to Android devices using Google Firebase Cloud Messaging

Questa esercitazione illustra come usare Hub di notifica di Azure e Firebase Cloud Messaging (FCM) per inviare notifiche push a un'applicazione Android.This tutorial shows you how to use Azure Notification Hubs and Firebase Cloud Messaging (FCM) to push notifications to an Android application. In questa esercitazione verrà creata un'app Android vuota che riceve notifiche push tramite Firebase Cloud Messaging (FCM).In this tutorial, you create a blank Android app that receives push notifications by using Firebase Cloud Messaging (FCM).

Il codice completo per questa esercitazione può essere scaricato da GitHub.The completed code for this tutorial can be downloaded from GitHub.

In questa esercitazione vengono completati i passaggi seguenti:In this tutorial, you take the following steps:

  • Creare un progetto di Android Studio.Create an Android Studio project.
  • Creare un progetto Firebase che supporta Firebase Cloud Messaging.Create a Firebase project that supports Firebase Cloud Messaging.
  • Creare un hub.Create a hub.
  • Connettere l'app all'hub.Connect your app to the hub.
  • Testare l'app.Test the app.

PrerequisitiPrerequisites

Per completare l'esercitazione, è necessario disporre di un account Azure attivo.To complete this tutorial, you must have an active Azure account. Se non si dispone di un account Azure, è possibile creare un account di valutazione gratuito in pochi minuti.If you don't have an account, you can create a free trial account in just a couple of minutes. Per informazioni dettagliate, vedere la pagina relativa alla versione di valutazione gratuita di Azure.For details, see Azure Free Trial.

Sono necessari anche gli elementi seguenti:You also need the following items:

  • Ultima versione di Android StudioThe latest version of Android Studio
  • Android 2.3 o versione successiva per Firebase Cloud MessagingAndroid 2.3 or higher for Firebase Cloud Messaging
  • Google Repository revisione 27 o successiva per Firebase Cloud MessagingGoogle Repository revision 27 or higher for Firebase Cloud Messaging
  • Google Play Services 9.0.2 o versione successiva per Firebase Cloud MessagingGoogle Play Services 9.0.2 or higher for Firebase Cloud Messaging

Il completamento di questa esercitazione costituisce un prerequisito per tutte le altre esercitazioni su Hub di notifica per app Android.Completing this tutorial is a prerequisite for doing all other Notification Hubs tutorials for Android apps.

Creare un progetto di Android StudioCreate an Android Studio Project

  1. Avviare Android Studio.Launch Android Studio.
  2. Selezionare File, scegliere New (Nuovo) e quindi New Project (Nuovo progetto).Select File, point to New, and then select New Project.
  3. Nella pagina Choose your project (Scegliere il progetto) selezionare Empty Activity (Attività vuota) e quindi Next (Avanti).On the Choose your project page, select Empty Activity, and then select Next.
  4. Nella pagina Configure your project (Configurare il progetto) completare questi passaggi:On the Configure your project page, take the following steps:
    1. Immettere un nome per l'applicazione.Enter a name for the application.

    2. Specificare un percorso in cui salvare i file del progetto.Specify a location in which to save the project files.

    3. Selezionare Fine.Select Finish.

      Configurare il progetto

Creare un progetto Firebase che supporta FCMCreate a Firebase project that supports FCM

  1. Accedere alla console di Firebase.Sign in to the Firebase console. Creare un nuovo progetto Firebase se non è già disponibile.Create a new Firebase project if you don't already have one.

  2. Dopo aver creato il progetto, selezionare Add Firebase to your Android app (Aggiungi Firebase all'app Android).After you create your project, select Add Firebase to your Android app.

    Aggiungere Firebase all'app Android

  3. Nella pagina Aggiungere Firebase all'app Android seguire questa procedura:On the Add Firebase to your Android app page, take the following steps:

    1. Per Android package name (Nome pacchetto Android), copiare il valore di applicationId nel file build.gradle dell'applicazione.For Android package name, copy the value of your applicationId in your application's build.gradle file. In questo esempio è com.fabrikam.fcmtutorial1app.In this example, it's com.fabrikam.fcmtutorial1app.

      Specificare il nome del pacchetto

    2. Selezionare Registra l'app.Select Register app.

  4. Selezionare Download google-services.json (Scarica google-services.json), salvare il file nella cartella app del progetto e quindi selezionare Avanti.Select Download google-services.json, save the file into the app folder of your project, and then select Next.

    Scaricare google-services.json

  5. Apportare le seguenti modifiche di configurazione al progetto in Android Studio.Make the following configuration changes to your project in Android Studio.

    1. Nel file project-level build.gradle (<project>/build.gradle) aggiungere l'istruzione seguente alla sezione dependencies.In your project-level build.gradle file (<project>/build.gradle), add the following statement to the dependencies section.

      classpath 'com.google.gms:google-services:4.0.1'
      
    2. Nel file app-level build.gradle (<project>/<app-module>/build.gradle) aggiungere le istruzioni seguenti alla sezione dependencies.In your app-level build.gradle file (<project>/<app-module>/build.gradle), add the following statements to the dependencies section.

      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.Add the following line to the end of the app-level build.gradle file after the dependencies section.

      apply plugin: 'com.google.gms.google-services'
      
    4. Selezionare Sincronizza ora sulla barra degli strumenti.Select Sync now on the toolbar.

      Modifiche di configurazione a build.gradle

  6. Selezionare Avanti.Select Next.

  7. Selezionare Ignora questo passaggio.Select Skip this step.

    Ignorare l'ultimo passaggio

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

    Selezionare Project Settings (Impostazioni progetto)

  9. Se il file google-services.json non è stato scaricato nella cartella app del progetto di Android Studio, è possibile eseguire questa operazione in questa pagina.If you haven't downloaded the google-services.json file into the app folder of your Android Studio project, you can do so on this page.

  10. Passare alla scheda Cloud Messaging in alto.Switch to the Cloud Messaging tab at the top.

  11. Copiare e salvare il valore di Chiave server per un uso successivo.Copy and save the Server key for later use. Questo valore viene usato per configurare l'hub.You use this value to configure your hub.

Configurare un hubConfigure a hub

  1. Accedere al portale di Azure.Sign in to the Azure portal.

  2. Scegliere Tutti i servizi dal menu a sinistra e quindi selezionare Hub di notifica nella sezione Dispositivi mobili.Select All services on the left menu, and then select Notification Hubs in the Mobile section. Selezionare l'icona a forma di stella accanto al nome del servizio per aggiungere il servizio alla sezione PREFERITI nel menu a sinistra.Select the star icon next to the service name to add the service to the FAVORITES section on the left menu. Dopo aver aggiunto Hub di notifica a PREFERITI, selezionarlo nel menu a sinistra.After you add Notification Hubs to FAVORITES, select it on the left menu.

    Portale di Azure - Selezionare Hub di notifica

  3. Nella pagina Hub di notifica selezionare Aggiungi sulla barra degli strumenti.On the Notification Hubs page, select Add on the toolbar.

    Hub di notifica - Pulsante Aggiungi della barra degli strumenti

  4. Nella pagina Hub di notifica procedere come segue:On the Notification Hub page, do the following steps:

    1. Immettere un nome in Hub di notifica.Enter a name in Notification Hub.

    2. Immettere un nome in Crea un nuovo spazio dei nomi.Enter a name in Create a new namespace. Uno spazio dei nomi contiene uno o più hub.A namespace contains one or more hubs.

    3. Selezionare un valore nell'elenco a discesa Posizione.Select a value from the Location drop-down list box. Questo valore specifica la posizione in cui creare l'hub.This value specifies the location in which you want to create the hub.

    4. Selezionare un gruppo di risorse esistente in Gruppo di risorse o creare un nome per un nuovo gruppo di risorse.Select an existing resource group in Resource Group, or create a name for a new resource group.

    5. Selezionare Create (Crea).Select Create.

      Portale di Azure: impostare le proprietà dell'hub di notifica

  5. Selezionare Notifiche (icona a forma di campanello) e quindi selezionare Vai alla risorsa.Select Notifications (the bell icon), and then select Go to resource. È anche possibile aggiornare l'elenco nella pagina Hub di notifica e selezionare l'hub.You can also refresh the list on the Notification Hubs page and select your hub.

    Portale di Azure - Notifiche -> Vai alla risorsa

  6. Selezionare Criteri di accesso dall'elenco.Select Access Policies from the list. Prendere nota delle due stringhe di connessione disponibili.Note that the two connection strings are available to you. Sono necessarie in un secondo momento per gestire le notifiche push.You'll need them later to handle push notifications.

    Importante

    Non usare il criterio DefaultFullSharedAccessSignature nell'applicazione.Do not use the DefaultFullSharedAccessSignature policy in your application. Deve essere usato solo nel back-end.This is meant to be used in your back end only.

    Portale di Azure: stringhe di connessione dell'hub di notifica

Configurare le impostazioni di Firebase Cloud Messaging per l'hubConfigure Firebase Cloud Messaging settings for the hub

  1. Nel riquadro a sinistra in Settings (Impostazioni) selezionare Google (GCM/FCM) .In the left pane, under Settings, select Google (GCM/FCM).

  2. Immettere la chiave del server per il progetto FCM salvato in precedenza.Enter the server key for the FCM project that you saved earlier.

  3. Sulla barra degli strumenti selezionareSave (Salva).On the toolbar, select Save.

    Hub di notifica di Azure - Google (FCM)

  4. Nella sezione degli avvisi del portale di Azure viene visualizzato un messaggio che indica che l'hub è stato aggiornato.The Azure portal displays a message in alerts that the hub has been successfully updated. Il pulsante Save (Salva) è disabilitato.The Save button is disabled.

L'hub è ora configurato per l'uso di Firebase Cloud Messaging.Your hub is now configured to work with Firebase Cloud Messaging. Sono anche disponibili le stringhe di connessione necessarie per inviare notifiche a un dispositivo e registrare un'app per la ricezione di notifiche.You also have the connection strings that are necessary to send notifications to a device and register an app to receive notifications.

Connettere l'app all'hub di notificaConnect your app to the notification hub

Aggiungere Google Play Services al progettoAdd Google Play services to the project

  1. In Android Studio selezionare Strumenti nel menu e quindi SDK Manager.In Android Studio, select Tools on the menu, and then select SDK Manager.

  2. Selezionare la versione di destinazione di Android SDK che viene usata nel progetto.Select the target version of the Android SDK that is used in your project. Quindi selezionare Mostra i dettagli del pacchetto.Then select Show Package Details.

    Android SDK Manager: selezionare la versione di destinazione

  3. Selezionare API Google, se non è già installato.Select Google APIs, if it's not already installed.

    Android SDK Manager: selezione di Google APIs (API Google)

  4. Passare alla scheda SDK Tools. Se lo strumento Google Play Services non è già installato, fare clic su Google Play Services come illustrato nell'immagine di seguito.Switch to the SDK Tools tab. If you haven't already installed Google Play Services, select Google Play Services as shown in the following image. Selezionare Applica per installarlo.Then select Apply to install. Prendere nota del percorso dell'SDK per l'uso in un passaggio successivo.Note the SDK path, for use in a later step.

    Android SDK Manager: selezione di Google Play Services

  5. Se viene visualizzata la finestra di dialogo Confirm Change (Conferma modifica), selezionare OK.If you see the Confirm Change dialog box, select OK. Il programma di installazione componenti installa i componenti richiesti.The Component Installer installs the requested components. Al termine dell'installazione dei componenti, selezionare Finish (Fine).Select Finish after the components are installed.

  6. Selezionare OK per chiudere la finestra di dialogo Settings for New Projects (Impostazioni per nuovi progetti).Select OK to close the Settings for New Projects dialog box.

  7. Aprire il file AndroidManifest.xml e quindi aggiungere il tag seguente al tag dell'applicazione.Open the AndroidManifest.xml file, and then add the following tag to the application tag.

    <meta-data android:name="com.google.android.gms.version"
         android:value="@integer/google_play_services_version" />
    

Aggiungere le librerie di Hub di notifica di AzureAdd Azure Notification Hubs libraries

  1. Nel file Build.Gradle per l'app aggiungere le righe seguenti nella sezione dependencies.In the Build.Gradle file for the app, add the following lines in the dependencies section.

    implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
    
  2. Aggiungere il repository seguente dopo la sezione dependencies.Add the following repository after the dependencies section.

    repositories {
        maven {
            url "https://dl.bintray.com/microsoftazuremobile/SDK"
        }
    }
    

Aggiungere il supporto di Google FirebaseAdd Google Firebase support

  1. Nel file Build.Gradle per l'app aggiungere le righe seguenti nella sezione dependencies se non sono già presenti.In the Build.Gradle file for the app, add the following lines in the dependencies section if they don't already exist.

    implementation 'com.google.firebase:firebase-core:16.0.8'
    implementation 'com.google.firebase:firebase-messaging:17.3.4'
    
  2. Aggiungere il plug-in seguente alla fine del file se non è già presente.Add the following plug-in at the end of the file if it's not already there.

    apply plugin: 'com.google.gms.google-services'
    
  3. Selezionare Sync Now (Sincronizza ora) sulla barra degli strumenti.Select Sync Now on the toolbar.

Aggiornare il file AndroidManifest.xmlUpdate the AndroidManifest.xml file

  1. Dopo aver ricevuto il token di registrazione di FCM, usarlo per la registrazione in Hub di notifica di Azure.After you receive your FCM registration token, you use it to register with Azure Notification Hubs. La registrazione viene supportata in background mediante un servizio IntentService denominato RegistrationIntentService.You support this registration in the background by using an IntentService named RegistrationIntentService. Il servizio aggiorna anche il token di registrazione di FCM.This service also refreshes your FCM registration token. Si crea anche una classe denominata FirebaseService come sottoclasse di FirebaseMessagingService e si esegue l'override del metodo onMessageReceived per ricevere e gestire le notifiche.You also create a class named FirebaseService as a subclass of FirebaseMessagingService and override the onMessageReceived method to receive and handle notifications.

    Aggiungere la definizione del servizio seguente al file AndroidManifest.xml, all'interno del tag <application> .Add the following service definition to the AndroidManifest.xml file, inside the <application> tag.

    <service
        android:name=".RegistrationIntentService"
        android:exported="false">
    </service>
    <service
        android:name=".FirebaseService"
        android:exported="false">
        <intent-filter>
            <action android:name="com.google.firebase.MESSAGING_EVENT" />
        </intent-filter>
    </service>
    
  2. Aggiungere le autorizzazioni necessarie relative a FCM sotto il tag </application>.Add the following necessary FCM-related permissions below the </application> tag.

    <uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.GET_ACCOUNTS"/>
    <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
    

Aggiungere codiceAdd code

  1. Nella visualizzazione del progetto espandere app > src > main > java.In the Project View, expand app > src > main > java. Fare clic con il pulsante destro del mouse sulla cartella del pacchetto in java, scegliere New (Nuovo), quindi selezionare Java Class (Classe Java).Right-click your package folder under java, select New, and then select Java Class. Immettere Notification Settings come nome e quindi scegliere OK.Enter NotificationSettings for the name, and then select OK.

    Aggiornare questi tre segnaposto nel codice seguente per la classe NotificationSettings:Make sure to update these three placeholders in the following code for the NotificationSettings class:

    • HubListenConnectionString: la stringa di connessione DefaultListenAccessSignature per l'hub.HubListenConnectionString: The DefaultListenAccessSignature connection string for your hub. È possibile copiare la stringa di connessione facendo clic su Criteri di accesso nell'hub nel portale di Azure.You can copy that connection string by clicking Access Policies in your hub in the Azure portal.

    • HubName: Usare il nome dell'hub visualizzato nella pagina dell'hub del portale di Azure.HubName: Use the name of your hub that appears in the hub page in the Azure portal.

      NotificationSettings :NotificationSettings code:

      public class NotificationSettings {
          public static String HubName = "<Your HubName>";
          public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
      }
      

      Importante

      Immettere il nome e il valore di DefaultListenSharedAccessSignature dell'hub prima di continuare.Enter the name and the DefaultListenSharedAccessSignature of your hub before proceeding further.

  2. Aggiungere al progetto un'altra nuova classe denominata RegistrationIntentService.Add another new class to your project named RegistrationIntentService. La classe implementa l'interfaccia IntentService.This class implements the IntentService interface. La classe gestisce anche l'aggiornamento del token di FCM e la registrazione nell'hub di notifica.It also handles refreshing the FCM token and registering with the notification hub.

    Usare il codice seguente per la classe.Use the following code for this class.

    import android.app.IntentService;
    import android.content.Intent;
    import android.content.SharedPreferences;
    import android.preference.PreferenceManager;
    import android.util.Log;
    import com.google.android.gms.tasks.OnSuccessListener;
    import com.google.firebase.iid.FirebaseInstanceId;
    import com.google.firebase.iid.InstanceIdResult;
    import com.microsoft.windowsazure.messaging.NotificationHub;
    import java.util.concurrent.TimeUnit;
    
    public class RegistrationIntentService extends IntentService {
    
        private static final String TAG = "RegIntentService";
        String FCM_token = null;
    
        private NotificationHub hub;
    
        public RegistrationIntentService() {
            super(TAG);
        }
    
        @Override
        protected void onHandleIntent(Intent intent) {
    
            SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
            String resultString = null;
            String regID = null;
            String storedToken = null;
    
            try {
                FirebaseInstanceId.getInstance().getInstanceId().addOnSuccessListener(new OnSuccessListener<InstanceIdResult>() { 
                    @Override 
                    public void onSuccess(InstanceIdResult instanceIdResult) { 
                        FCM_token = instanceIdResult.getToken(); 
                        Log.d(TAG, "FCM Registration Token: " + FCM_token); 
                    } 
                }); 
                TimeUnit.SECONDS.sleep(1);
    
                // Storing the registration ID that indicates whether the generated token has been
                // sent to your server. If it is not stored, send the token to your server.
                // Otherwise, your server should have already received the token.
                if (((regID=sharedPreferences.getString("registrationID", null)) == null)){
    
                    NotificationHub hub = new NotificationHub(NotificationSettings.HubName,
                            NotificationSettings.HubListenConnectionString, this);
                    Log.d(TAG, "Attempting a new registration with NH using FCM token : " + FCM_token);
                    regID = hub.register(FCM_token).getRegistrationId();
    
                    // If you want to use tags...
                    // Refer to : https://azure.microsoft.com/documentation/articles/notification-hubs-routing-tag-expressions/
                    // regID = hub.register(token, "tag1,tag2").getRegistrationId();
    
                    resultString = "New NH Registration Successfully - RegId : " + regID;
                    Log.d(TAG, resultString);
    
                    sharedPreferences.edit().putString("registrationID", regID ).apply();
                    sharedPreferences.edit().putString("FCMtoken", FCM_token ).apply();
                }
    
                // Check to see if the token has been compromised and needs refreshing.
                else if ((storedToken=sharedPreferences.getString("FCMtoken", "")) != FCM_token) {
    
                    NotificationHub hub = new NotificationHub(NotificationSettings.HubName,
                            NotificationSettings.HubListenConnectionString, this);
                    Log.d(TAG, "NH Registration refreshing with token : " + FCM_token);
                    regID = hub.register(FCM_token).getRegistrationId();
    
                    // If you want to use tags...
                    // Refer to : https://azure.microsoft.com/documentation/articles/notification-hubs-routing-tag-expressions/
                    // regID = hub.register(token, "tag1,tag2").getRegistrationId();
    
                    resultString = "New NH Registration Successfully - RegId : " + regID;
                    Log.d(TAG, resultString);
    
                    sharedPreferences.edit().putString("registrationID", regID ).apply();
                    sharedPreferences.edit().putString("FCMtoken", FCM_token ).apply();
                }
    
                else {
                    resultString = "Previously Registered Successfully - RegId : " + regID;
                }
            } catch (Exception e) {
                Log.e(TAG, resultString="Failed to complete registration", e);
                // If an exception happens while fetching the new token or updating registration data
                // on a third-party server, this ensures that we'll attempt the update at a later time.
            }
    
            // Notify UI that registration has completed.
            if (MainActivity.isVisible) {
                MainActivity.mainActivity.ToastNotify(resultString);
            }
        }
    }
    
  3. Nella classe MainActivity aggiungere le istruzioni import seguenti sopra la dichiarazione della classe.In the MainActivity class, add the following import statements above the class declaration.

    import com.google.android.gms.common.ConnectionResult;
    import com.google.android.gms.common.GoogleApiAvailability;
    import android.content.Intent;
    import android.util.Log;
    import android.widget.TextView;
    import android.widget.Toast;
    
  4. Aggiungere i membri seguenti nella parte superiore della classe.Add the following members at the top of the class. Questi campi vengono usati per verificare la disponibilità di Google Play Services come consigliato da Google.You use these fields to check the availability of Google Play Services as recommended by Google.

    public static MainActivity mainActivity;
    public static Boolean isVisible = false;
    private static final String TAG = "MainActivity";
    private static final int PLAY_SERVICES_RESOLUTION_REQUEST = 9000;
    
  5. Nella classe MainActivity aggiungere il metodo seguente per verificare la disponibilità di Google Play Services.In the MainActivity class, add the following method to check the availability of Google Play Services.

    /**
    * Check the device to make sure it has the Google Play Services APK. If
    * it doesn't, display a dialog box that enables  users to download the APK from
    * the Google Play Store or enable it in the device's system settings.
    */
    
    private boolean checkPlayServices() {
        GoogleApiAvailability apiAvailability = GoogleApiAvailability.getInstance();
        int resultCode = apiAvailability.isGooglePlayServicesAvailable(this);
        if (resultCode != ConnectionResult.SUCCESS) {
            if (apiAvailability.isUserResolvableError(resultCode)) {
                apiAvailability.getErrorDialog(this, resultCode, PLAY_SERVICES_RESOLUTION_REQUEST)
                        .show();
            } else {
                Log.i(TAG, "This device is not supported by Google Play Services.");
                ToastNotify("This device is not supported by Google Play Services.");
                finish();
            }
            return false;
        }
        return true;
    }
    
  6. Nella classe MainActivity aggiungere il codice seguente, che verifica la presenza di Google Play Services prima di chiamare IntentService per ottenere il token di registrazione di FCM e registrarlo nell'hub:In the MainActivity class, add the following code that checks for Google Play Services before calling the IntentService to get your FCM registration token and register with your hub:

    public void registerWithNotificationHubs()
    {
        if (checkPlayServices()) {
            // Start IntentService to register this application with FCM.
            Intent intent = new Intent(this, RegistrationIntentService.class);
            startService(intent);
        }
    }
    
  7. Nel metodo OnCreate della classe MainActivity aggiungere il codice seguente per avviare il processo di registrazione quando viene creata l'attività:In the OnCreate method of the MainActivity class, add the following code to start the registration process when the activity is created:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    
        mainActivity = this;
        registerWithNotificationHubs();
        FirebaseService.createChannelAndHandleNotifications(getApplicationContext());
    }
    
  8. Per verificare lo stato dell'app e segnalare lo stato nell'app, aggiungere questi altri metodi a MainActivity:To verify app state and report status in your app, add these additional methods to MainActivity:

    @Override
    protected void onStart() {
        super.onStart();
        isVisible = true;
    }
    
    @Override
    protected void onPause() {
        super.onPause();
        isVisible = false;
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        isVisible = true;
    }
    
    @Override
    protected void onStop() {
        super.onStop();
        isVisible = false;
    }
    
    public void ToastNotify(final String notificationMessage) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                Toast.makeText(MainActivity.this, notificationMessage, Toast.LENGTH_LONG).show();
                TextView helloText = (TextView) findViewById(R.id.text_hello);
                helloText.setText(notificationMessage);
            }
        });
    }
    
  9. Il metodo ToastNotify usa il controllo "Hello World" TextView per segnalare lo stato e le notifiche in modo permanente nell'app.The ToastNotify method uses the "Hello World" TextView control to report status and notifications persistently in the app. Nel layout res > layout > activity_main.xml aggiungere l'ID seguente per questo controllo.In your res > layout > activity_main.xml layout, add the following ID for that control.

    android:id="@+id/text_hello"
    

    Hub di notifica di Azure: test dell'invio

  10. Aggiungere quindi una sottoclasse per il ricevitore definito nel file AndroidManifest.xml.Next you add a subclass for the receiver that you defined in AndroidManifest.xml. Aggiungere al progetto un'altra nuova classe denominata FirebaseService.Add another new class to your project named FirebaseService.

  11. Aggiungere le istruzioni import seguenti all'inizio di FirebaseService.java:Add the following import statements at the top of FirebaseService.java:

    import com.google.firebase.messaging.FirebaseMessagingService;
    import com.google.firebase.messaging.RemoteMessage;
    import android.util.Log;
    import android.app.NotificationChannel;
    import android.app.NotificationManager;
    import android.app.PendingIntent;
    import android.content.Context;
    import android.content.Intent;
    import android.media.RingtoneManager;
    import android.net.Uri;
    import android.os.Build;
    import android.os.Bundle;
    import androidx.core.app.NotificationCompat;
    
  12. Aggiungere il codice seguente per la classe FirebaseService, impostandola come sottoclasse di FirebaseMessagingService.Add the following code for the FirebaseService class, making it a subclass of FirebaseMessagingService.

    Questo codice esegue l'override del metodo onMessageReceived e segnala le notifiche ricevute.This code overrides the onMessageReceived method and reports notifications that are received. Invia anche la notifica push al gestore delle notifiche di Android usando il metodo sendNotification().it also sends the push notification to the Android notification manager by using the sendNotification() method. Chiamare il metodo sendNotification() quando l'app non è in esecuzione e viene ricevuta una notifica.Call the sendNotification() method when the app isn't running and a notification is received.

    public class FirebaseService extends FirebaseMessagingService
    {
        private String TAG = "FirebaseService";
    
        public static final String NOTIFICATION_CHANNEL_ID = "nh-demo-channel-id";
        public static final String NOTIFICATION_CHANNEL_NAME = "Notification Hubs Demo Channel";
        public static final String NOTIFICATION_CHANNEL_DESCRIPTION = "Notification Hubs Demo Channel";
    
        public static final int NOTIFICATION_ID = 1;
        private NotificationManager mNotificationManager;
        NotificationCompat.Builder builder;
        static Context ctx;
    
        @Override
        public void onMessageReceived(RemoteMessage remoteMessage) {
            // ...
    
            // TODO(developer): Handle FCM messages here.
            // Not getting messages here? See why this may be: https://goo.gl/39bRNJ
            Log.d(TAG, "From: " + remoteMessage.getFrom());
    
            String nhMessage;
            // Check if message contains a notification payload.
            if (remoteMessage.getNotification() != null) {
                Log.d(TAG, "Message Notification Body: " + remoteMessage.getNotification().getBody());
    
                nhMessage = remoteMessage.getNotification().getBody();
            }
            else {
                nhMessage = remoteMessage.getData().values().iterator().next();
            }
    
            // Also if you intend on generating your own notifications as a result of a received FCM
            // message, here is where that should be initiated. See sendNotification method below.
            if (MainActivity.isVisible) {
                MainActivity.mainActivity.ToastNotify(nhMessage);
            }
            sendNotification(nhMessage);
        }
    
        private void sendNotification(String msg) {
    
            Intent intent = new Intent(ctx, MainActivity.class);
            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    
            mNotificationManager = (NotificationManager)
                    ctx.getSystemService(Context.NOTIFICATION_SERVICE);
    
            PendingIntent contentIntent = PendingIntent.getActivity(ctx, 0,
                    intent, PendingIntent.FLAG_ONE_SHOT);
    
            Uri defaultSoundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
            NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(
                    ctx,
                    NOTIFICATION_CHANNEL_ID)
                    .setContentText(msg)
                    .setPriority(NotificationCompat.PRIORITY_HIGH)
                    .setSmallIcon(android.R.drawable.ic_popup_reminder)
                    .setBadgeIconType(NotificationCompat.BADGE_ICON_SMALL);
    
            notificationBuilder.setContentIntent(contentIntent);
            mNotificationManager.notify(NOTIFICATION_ID, notificationBuilder.build());
        }
    
        public static void createChannelAndHandleNotifications(Context context) {
            ctx = context;
    
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                NotificationChannel channel = new NotificationChannel(
                        NOTIFICATION_CHANNEL_ID,
                        NOTIFICATION_CHANNEL_NAME,
                        NotificationManager.IMPORTANCE_HIGH);
                channel.setDescription(NOTIFICATION_CHANNEL_DESCRIPTION);
                channel.setShowBadge(true);
    
                NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
                notificationManager.createNotificationChannel(channel);
             }
        }
    }
    
  13. Sulla barra dei menu di Android Studio fare clic su Compila > Ricompila progetto per assicurarsi che il codice non contenga errori.In Android Studio, on the menu bar, select Build > Rebuild Project to make sure that there aren't any errors in your code. Se si riceve un errore riguardo all'icona ic_launcher, rimuovere l'istruzione seguente dal file AndroidManifest.xml:If you receive an error about the ic_launcher icon, remove the following statement from the AndroidManifest.xml file:

        android:icon="@mipmap/ic_launcher"
    
  14. Assicurarsi di disporre di un dispositivo virtuale per l'esecuzione dell'app.Ensure you have a virtual device for running the app. Se non è presente, aggiungerne uno nel modo seguente:If you do not have one, add one as follows:

    1. Aprire Gestione dispositivi
    2. Creare il dispositivo virtuale
  15. Eseguire l'app nel dispositivo selezionato e verificare che venga registrata correttamente nell'hub.Run the app on your selected device and verify that it registers successfully with the hub.

    Nota

    La registrazione può non riuscire durante l'avvio iniziale, fino a quando non viene chiamato il metodo onTokenRefresh() del servizio Instance ID.Registration might fail during the initial launch until the onTokenRefresh() method of the instance ID service is called. L'aggiornamento deve avviare una registrazione corretta con l'hub di notifica.The refresh should initiate a successful registration with the notification hub.

    Il dispositivo è stato registrato

Testare la notifica di invio dall'hub di notificaTest send notification from the notification hub

È possibile inviare notifiche push dal portale di Azure eseguendo questi passaggi:You can send push notifications from the Azure portal by taking the following steps:

  1. Nella pagina Hub di notifica per l'hub nel portale di Azure selezionare Invio di prova nella sezione Risoluzione dei problemi.In the Azure portal, on the Notification Hub page for your hub, select Test Send in the Troubleshooting section.

  2. Per Platforms (Piattaforme) selezionare Android.For Platforms, select Android.

  3. Selezionare Send (Invia).Select Send. Non verrà visualizzata alcuna notifica nel dispositivo Android, perché nel dispositivo non è stata ancora eseguita l'app per dispositivi mobili.You won't see a notification on the Android device yet because you haven't run the mobile app on it. Dopo aver eseguito l'app per dispositivi mobili, selezionare di nuovo il pulsante Invia per visualizzare il messaggio di notifica.After you run the mobile app, select the Send button again to see the notification message.

  4. Osservare i risultati dell'operazione nell'elenco in fondo.See the result of the operation in the list at the bottom.

    Hub di notifica di Azure: test dell'invio

  5. Il messaggio di notifica viene visualizzato nel dispositivo.You see the notification message on your device.

    Messaggio di notifica nel dispositivo

Le notifiche push vengono in genere inviate in un servizio back-end come App per dispositivi mobili o ASP.NET usando una libreria compatibile.Push notifications are normally sent in a back-end service like Mobile Apps or ASP.NET using a compatible library. Se non è disponibile una libreria per il back-end è anche possibile usare direttamente l'API REST per inviare messaggi di notifica.If a library isn't available for your back end, you can also use the REST API directly to send notification messages.

Di seguito è riportato un elenco di altre esercitazioni, che è possibile esaminare per l'invio di notifiche:Here is a list of some other tutorials you might want to review for sending notifications:

Eseguire l'app per dispositivi mobili nell'emulatoreRun the mobile app on emulator

Prima di testare le notifiche push all'interno dell'emulatore, assicurarsi che l'immagine dell'emulatore supporti il livello Google API scelto per l'app.Before you test push notifications inside an emulator, make sure that your emulator image supports the Google API level that you chose for your app. Se l'immagine non supporta le API di Google in modalità nativa, è possibile che venga generata l'eccezione SERVICE_NOT_AVAILABLE.If your image doesn't support native Google APIs, you might get the SERVICE_NOT_AVAILABLE exception.

Assicurarsi anche di avere aggiunto l'account Google all'emulatore in esecuzione in Impostazioni > Account.Also make sure that you've added your Google account to your running emulator under Settings > Accounts. In caso contrario, i tentativi di registrazione in FCM possono generare l'eccezione AUTHENTICATION_FAILED.Otherwise, your attempts to register with FCM might result in the AUTHENTICATION_FAILED exception.

Passaggi successiviNext steps

In questa esercitazione è stato usato Firebase Cloud Messaging per trasmettere notifiche a tutti i dispositivi Android registrati nel servizio.In this tutorial, you used Firebase Cloud Messaging to broadcast notifications to all Android devices that were registered with the service. Per informazioni sulle procedure per eseguire il push di notifiche a dispositivi specifici, passare all'esercitazione seguente:To learn how to push notifications to specific devices, advance to the following tutorial: