Esercitazione: Eseguire il push di notifiche ai dispositivi Android con Hub di notifica di Azure e Google Firebase Cloud MessagingTutorial: Push notifications to Android devices by using Azure Notification Hubs and Google Firebase Cloud Messaging

Importante

Questo articolo illustra le notifiche push con Google Firebase Cloud Messaging (FCM).This article demonstrates push notifications with Google Firebase Cloud Messaging (FCM). Se si sta ancora usando Google Cloud Messaging (GCM), vedere Push notifications to Android devices with Azure Notification Hubs and GCM (Invio di notifiche push ai dispositivi Android con Hub di notifica di Azure e GCM).If you are still using Google Cloud Messaging (GCM), see Push notifications to Android devices with Azure Notification Hubs and GCM.

Questa esercitazione illustra come usare Hub di notifica di Azure e Firebase Cloud Messaging per inviare notifiche push a un'applicazione Android.This tutorial shows you how to use Azure Notification Hubs and Firebase Cloud Messaging 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 qui.The completed code for this tutorial can be downloaded from GitHub here.

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 di notifica.Create a notification hub.
  • Connettere l'app all'hub di notifica.Connect your app to the notification 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.

  • Oltre a un account Azure attivo come indicato sopra, questa esercitazione richiede la versione più recente di Android Studio.In addition to an active Azure account mentioned above, this tutorial requires the latest version of Android Studio.
  • Android 2.3 o versione successiva per Firebase Cloud Messaging.Android 2.3 or higher for Firebase Cloud Messaging.
  • Google Repository revision 27 o versione successiva è richiesta per Firebase Cloud Messaging.Google Repository revision 27 or higher is required for Firebase Cloud Messaging.
  • Google Play Services 9.0.2 o versione successiva per Firebase Cloud Messaging.Google Play Services 9.0.2 or higher for Firebase Cloud Messaging.
  • Il completamento di questa esercitazione costituisce un prerequisito per tutte le altre esercitazioni di Hub di notifica relative ad app Android.Completing this tutorial is a prerequisite for all other Notification Hubs tutorials for Android apps.

Creare un progetto di Android StudioCreate an Android Studio Project

  1. In Android Studio avviare un nuovo progetto Android Studio.In Android Studio, start a new Android Studio project.

    Android Studio: nuovo progetto

  2. Scegliere il fattore di forma Phone and Tablet (Telefono e tablet) e la versione Minimum SDK (SDK minimo) che si vuole supportare.Choose the Phone and Tablet form factor and the Minimum SDK that you want to support. Quindi fare clic su Next.Then click Next.

    Android Studio: flusso di lavoro di creazione del progetto

  3. Scegliere Empty Activity (Attività vuota) per l'attività principale, fare clic su Avanti, quindi su Fine.Choose Empty Activity for the main activity, click Next, and then click Finish.

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. Seguire quindi le istruzioni visualizzate.Then follow the instructions that are provided. Scaricare il file google-services.json.Download google-services.json file.

    Aggiungere Firebase all'app Android

  3. 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)

  4. Selezionare la scheda General (Generale) nelle impostazioni del progetto.Select the General tab in your project settings. Scaricare quindi il file google-services.json che contiene la chiave API del server e l'ID client.Then download the google-services.json file that contains the Server API key and Client ID.
  5. Selezionare la scheda Cloud Messaging nelle impostazioni del progetto e quindi copiare il valore di Legacy server key (Chiave server legacy).Select the Cloud Messaging tab in your project settings, and then copy the value of the Legacy server key. Questo valore verrà usato per configurare i criteri di accesso all'hub di notifica.You use this value to configure the notification hub access policy.

Configurare un hub di notificaConfigure a notification hub

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

  2. Selezionare Crea una risorsa > Dispositivi mobili > Hub di notifica.Select Create a resource > Mobile > Notification Hub.

    Portale di Azure: creare un hub di notifica

  3. Nella casella Hub di notifica digitare un nome univoco.In the Notification Hub box, type a unique name. Selezionare l'area, la sottoscrizione e il gruppo di risorse (se già disponibili).Select your Region, Subscription, and Resource Group (if you have one already).

    Se non si ha già uno spazio dei nomi del bus di servizio, è possibile usare il nome predefinito, che viene creato in base al nome dell'hub (se lo spazio dei nomi è disponibile).If you don't already have a service bus namespace, you can use the default name, which is created based on the hub name (if the namespace name is available).

    Se si ha già un spazio dei nomi del bus di servizio in cui si vuole creare l'hub, seguire questa proceduraIf you already have a service bus namespace that you want to create the hub in, follow these steps

    a.a. Nell'area Spazio dei nomi selezionare il collegamento Seleziona esistente.In the Namespace area, select the Select Existing link.

    b.b. Selezionare Create.Select Create.

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

  4. Selezionare Notifiche (icona a forma di campanello) e selezionare Vai alla risorsa.Select Notifications (Bell icon), and select Go to resource.

    Portale di Azure - Notifiche -> Vai alla risorsa

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

    Importante

    NON usare DefaultFullSharedAccessSignature nell'applicazione.Do NOT use the DefaultFullSharedAccessSignature 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. Selezionare Google (GCM) nella categoria IMPOSTAZIONI DI NOTIFICA.Select Google (GCM) in the NOTIFICATION SETTINGS category.
  2. Immettere la chiave API (chiave del server FCM) copiata in precedenza dalla console di Firebase.Enter the API key (FCM server key) you copied earlier from the Firebase console.
  3. Sulla barra degli strumenti selezionare Salva.Select Save on the toolbar.

    Hub di notifica di Azure - Google (GCM)

L'hub di notifica è ora configurato per l'uso con Firebase Cloud Messaging e sono disponibili le stringhe di connessione per registrare l'app per la ricezione e l'invio di notifiche push.Your notification hub is now configured to work with Firebase Cloud Messaging, and you have the connection strings to both register your app to receive and send push 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. Aprire Android SDK Manager facendo clic sull'icona della barra degli strumenti di Android Studio o su Strumenti > Android > SDK Manager nel menu.Open the Android SDK Manager by clicking the icon on the toolbar of Android Studio or by clicking Tools > Android > SDK Manager on the menu. Trovare la versione di destinazione di Android SDK usata nel progetto, aprirla facendo clic su Show Package Details (Visualizza dettagli pacchetto) e quindi scegliere Google APIs (API Google), se non è già installato.Locate the target version of the Android SDK that is used in your project, open it by clicking Show Package Details, and choose Google APIs, if it is not already installed.
  2. Fare sulla scheda SDK Tools . Se Google Play Service non è già installato, fare clic su Google Play Services come mostrato di seguito.Click the SDK Tools tab. If you haven't already installed Google Play Service, click Google Play Services as shown below. Fare quindi clic su Apply per installarlo.Then click 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.

  3. Aprire il file build.gradle nella directory dell'app.Open the build.gradle file in the app directory.

  4. In dependenciesaggiungere questa riga:Add this line under dependencies:

        compile 'com.google.android.gms:play-services-gcm:12.0.0'
    
  5. Fare clic sul pulsante Sync Project with Gradle Files sulla barra degli strumenti.Click the Sync Project with Gradle Files icon in the tool bar.
  6. Aprire AndroidManifest.xml e aggiungere il tag seguente al tag application .Open AndroidManifest.xml and add this tag to the application tag.

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

Aggiunta di librerie dell'Hub di notifica di AzureAdding Azure Notification Hubs libraries

  1. Nel file Build.Gradle relativo all'app aggiungere le righe seguenti alla sezione delle dipendenze.In the Build.Gradle file for the app, add the following lines in the dependencies section.

        compile 'com.microsoft.azure:notification-hubs-android-sdk:0.4@aar'
        compile 'com.microsoft.azure:azure-notifications-handler:1.0.1@aar'
    
  2. Aggiungere l'archivio seguente dopo la sezione dependencies .Add the following repository after the dependencies section.

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

Aggiungere il supporto di Google FirebaseAdd Google Firebase support

  1. Nel file Build.Gradle relativo all'app aggiungere le righe seguenti alla sezione delle dipendenze.In the Build.Gradle file for the app, add the following lines in the dependencies section.

        compile 'com.google.firebase:firebase-core:12.0.0'
    
  2. Aggiungere il plug-in seguente alla fine del file.Add the following plugin at the end of the file.

    apply plugin: 'com.google.gms.google-services'
    

Aggiornamento del file AndroidManifest.xmlUpdating the AndroidManifest.xml.

  1. Per supportare FCM è necessario implementare un servizio listener Instance ID nel codice, usato per ottenere token di registrazione usando l'API FirebaseInstanceId di Google.To support FCM, you must implement an Instance ID listener service in your code, which is used to obtain registration tokens using Google's FirebaseInstanceId API. In questa esercitazione, il nome della classe è MyInstanceIDService.In this tutorial, the name of the class is MyInstanceIDService.

    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=".MyInstanceIDService">
            <intent-filter>
                <action android:name="com.google.firebase.INSTANCE_ID_EVENT"/>
            </intent-filter>
        </service>
    
  2. Dopo la ricezione del token di registrazione di FCM dall'API FirebaseInstanceId, lo si usa per la registrazione con l'hub di notifica di Azure.Once you have received your FCM registration token from the FirebaseInstanceId API, you use it to register with the Azure Notification Hub. La registrazione viene supportata in background mediante un IntentService denominato RegistrationIntentService.You support this registration in the background using an IntentService named RegistrationIntentService. Il servizio è anche responsabile dell'aggiornamento del token di registrazione di FCM.This service is also responsible for refreshing your FCM registration token.

    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>
    
  3. È anche necessario definire un ricevitore per la ricezione delle notifiche.You need to also define a receiver to receive notifications. Aggiungere la definizione del ricevitore seguente al file AndroidManifest.xml, nel tag <application> .Add the following receiver definition to the AndroidManifest.xml file, inside the <application> tag. Sostituire il segnaposto <your package> con il nome effettivo del pacchetto visualizzato all'inizio del file AndroidManifest.xml.Replace the <your package> placeholder with your actual package name shown at the top of the AndroidManifest.xml file.

        <receiver android:name="com.microsoft.windowsazure.notifications.NotificationsBroadcastReceiver"
            android:permission="com.google.android.c2dm.permission.SEND">
            <intent-filter>
                <action android:name="com.google.android.c2dm.intent.RECEIVE" />
                <category android:name="<your package name>" />
            </intent-filter>
        </receiver>
    
  4. Aggiungere le autorizzazioni necessarie seguenti relative a FCM sotto il tag </application>.Add the following necessary FCM-related permissions below the </application> tag.

    Per altre informazioni su queste autorizzazioni, vedere Setup a GCM Client app for Android (Configurare un'app client FCM per Android) e Migrate a GCM Client App for Android to Firebase Cloud Messaging (Eseguire la migrazione di un'app client GCM per Android a Firebase Cloud Messaging).For more information on these permissions, see Setup a GCM Client app for Android and Migrate a GCM Client App for Android to Firebase Cloud Messaging.

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

Aggiunta di codiceAdding 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 Nuovo, quindi selezionare Java Class (Classe Java).Right-click your package folder under java, click New, and then click Java Class. Aggiungere una nuova classe denominata NotificationSettings.Add a new class named NotificationSettings.

    Android Studio: nuova classe Java

    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:

    • SenderId: ID mittente ottenuto in precedenza nella scheda Cloud Messaging delle impostazioni di progetto nella console di Firebase.SenderId: The Sender ID you obtained earlier in the Cloud Messaging tab of your project settings in the Firebase console.
    • HubListenConnectionString: 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 on the Azure portal.
    • HubName: usare il nome dell'hub di notifica visualizzato nella pagina dell'hub del portale di Azure.HubName: Use the name of your notification hub that appears in the hub page in the Azure portal.

      NotificationSettings :NotificationSettings code:

        public class NotificationSettings {
      
            public static String SenderId = "<Your project number>";
            public static String HubName = "<Your HubName>";
            public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
        }
      
  2. Usando la procedura precedente, aggiungere un'altra nuova classe denominata MyInstanceIDService.Using the steps preceding, add another new class named MyInstanceIDService. Questa classe è l'implementazione del servizio listener ID istanza.This class is your Instance ID listener service implementation.

    Il codice di questa classe chiama IntentService per aggiornare il token di FCM in background.The code for this class calls your IntentService to refresh the FCM token in the background.

        import android.content.Intent;
        import android.util.Log;
        import com.google.firebase.iid.FirebaseInstanceIdService;
    
        public class MyInstanceIDService extends FirebaseInstanceIdService {
    
            private static final String TAG = "MyInstanceIDService";
    
            @Override
            public void onTokenRefresh() {
    
                Log.d(TAG, "Refreshing GCM Registration Token");
    
                Intent intent = new Intent(this, RegistrationIntentService.class);
                startService(intent);
            }
        };
    
  3. Aggiungere al progetto un'altra nuova classe denominata RegistrationIntentService.Add another new class to your project named, RegistrationIntentService. Questa classe implementa l'interfaccia IntentService e gestisce l'aggiornamento del token di FCM e la registrazione nell'hub di notifica.This class implements the IntentService interface, and 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.firebase.iid.FirebaseInstanceId;
        import com.microsoft.windowsazure.messaging.NotificationHub;
    
        public class RegistrationIntentService extends IntentService {
    
            private static final String TAG = "RegIntentService";
    
            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 {
                    String FCM_token = FirebaseInstanceId.getInstance().getToken();
                    Log.d(TAG, "FCM Registration Token: " + FCM_token);
    
                    // 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 if the token may have 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 our 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);
                }
            }
        }
    
  4. Nella classe MainActivity aggiungere le istruzioni import seguenti sopra la dichiarazione della classe.In your 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 com.microsoft.windowsazure.notifications.NotificationsManager;
        import android.content.Intent;
        import android.util.Log;
        import android.widget.TextView;
        import android.widget.Toast;
    
  5. Aggiungere i seguenti membri privati nella parte superiore della classe.Add the following private 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;
    
  6. Nella classe MainActivity aggiungere il metodo seguente alla disponibilità di Google Play Services.In your MainActivity class, add the following method to 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 that allows 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;
        }
    
  7. Nella classe MainActivity aggiungere il codice seguente che cercherà Google Play Services prima di chiamare IntentService per ottenere il token di registrazione di FCM e registrarlo nell'hub di notifica.In your MainActivity class, add the following code that checks for Google Play Services before calling your IntentService to get your FCM registration token and register with your notification hub.

        public void registerWithNotificationHubs()
        {
            if (checkPlayServices()) {
                // Start IntentService to register this application with FCM.
                Intent intent = new Intent(this, RegistrationIntentService.class);
                startService(intent);
            }
        }
    
  8. 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 activity is created.

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            mainActivity = this;
            NotificationsManager.handleNotifications(this, NotificationSettings.SenderId, MyHandler.class);
            registerWithNotificationHubs();
        }
    
  9. Aggiungere questi altri metodi a MainActivity per verificare lo stato dell'app e segnalare lo stato nell'app.To verify app state and report status in your app, add these additional methods to the 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);
                }
            });
        }
    
  10. 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 di activity_main.xml aggiungere l'ID seguente per il controllo.In your activity_main.xml layout, add the following ID for that control.

       android:id="@+id/text_hello"
    
  11. Viene quindi aggiunta una sottoclasse per il ricevitore definito nel file AndroidManifest.xml.Next you add a subclass for your receiver you defined in the AndroidManifest.xml. Aggiungere al progetto un'altra nuova classe denominata MyHandler.Add another new class to your project named MyHandler.

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

        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.Bundle;
        import android.support.v4.app.NotificationCompat;
        import com.microsoft.windowsazure.notifications.NotificationsHandler;
    
  13. Aggiungere il codice seguente per la classe MyHandler impostandola come sottoclasse di com.microsoft.windowsazure.notifications.NotificationsHandler.Add the following code for the MyHandler class making it a subclass of com.microsoft.windowsazure.notifications.NotificationsHandler.

    Questo codice ignora il metodo OnReceive, quindi il gestore segnala le notifiche ricevute.This code overrides the OnReceive method, so the handler reports notifications that are received. Il gestore invia anche la notifica push al gestore delle notifiche di Android usando il metodo sendNotification() .The handler also sends the push notification to the Android notification manager by using the sendNotification() method. Il metodo sendNotification() deve essere eseguito quando l'app non è in esecuzione e si riceve una notifica.The sendNotification() method should be executed when the app is not running and a notification is received.

        public class MyHandler extends NotificationsHandler {
            public static final int NOTIFICATION_ID = 1;
            private NotificationManager mNotificationManager;
            NotificationCompat.Builder builder;
            Context ctx;
    
            @Override
            public void onReceive(Context context, Bundle bundle) {
                ctx = context;
                String nhMessage = bundle.getString("message");
                sendNotification(nhMessage);
                if (MainActivity.isVisible) {
                    MainActivity.mainActivity.ToastNotify(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 mBuilder =
                        new NotificationCompat.Builder(ctx)
                                .setSmallIcon(R.mipmap.ic_launcher)
                                .setContentTitle("Notification Hub Demo")
                                .setStyle(new NotificationCompat.BigTextStyle()
                                        .bigText(msg))
                                .setSound(defaultSoundUri)
                                .setContentText(msg);
    
                mBuilder.setContentIntent(contentIntent);
                mNotificationManager.notify(NOTIFICATION_ID, mBuilder.build());
            }
        }
    
  14. Sulla barra dei menu in Android Studio fare clic su Compila > Ricompila il progetto per assicurarsi che non ci siano errori nel codice.In Android Studio on the menu bar, click Build > Rebuild Project to make sure that no errors are present in your code.

  15. Eseguire l'app sul dispositivo e verificare che si registri correttamente con l'hub di notifica.Run the app on your device and verify it registers successfully with the notification hub.

    Nota

    La registrazione potrebbe non riuscire all'avvio iniziale, fino a quando non viene chiamato il metodo onTokenRefresh() del servizio Instance ID.Registration may fail on the initial launch until the onTokenRefresh() method of 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.

Testare l'appTest the app

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

È possibile inviare notifiche push dal portale di Azure eseguendo queste azioni:You can send push notifications from the Azure portal by doing the following actions:

  1. Selezionare Test Send (Invio di prova) nella sezione Troubleshooting (Risoluzione dei problemi).Select Test Send in the Troubleshooting section.
  2. Per Platforms (Piattaforme) selezionare Android.For Platforms, select Android.
  3. Selezionare Send (Invia).Select Send. Non è ancora presente una notifica sul dispositivo Android perché l'app per dispositivi mobile non è stata eseguita su di esso.You do not see a notification on the Android device yet because you haven't run the mobile app on it. Dopo aver eseguito l'app mobile, selezionare nuovamente il pulsante Send (Invia) per visualizzare il messaggio di notifica.After you run the mobile app, select Send button again to see the notification message.
  4. Vedere il risultato dell'operazione nell'elenco nella parte inferiore.See the result of the operation in the list at the bottom.

    Hub di notifica di Azure: test dell'invio

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 is not 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 may want to review for sending notifications:

Eseguire l'app per dispositivi mobiliRun the mobile app

Per testare le notifiche push all'interno dell'emulatore, assicurarsi che l'immagine dell'emulatore supporti il livello Google API scelto per l'app.If you want to 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 verrà generata l'eccezione SERVICE_NOT_AVAILABLE.If your image doesn't support native Google APIs, you end up with the SERVICE_NOT_AVAILABLE exception.

Verificare anche di avere aggiunto l'account Google all'emulatore in esecuzione in Impostazioni > Account.In addition, ensure that you have added your Google account to your running emulator under Settings > Accounts. In caso contrario, i tentativi di registrazione con GCM potrebbero generare l'eccezione AUTHENTICATION_FAILED.Otherwise, your attempts to register with GCM may result in the AUTHENTICATION_FAILED exception.

  1. Eseguire l'app e notare l'ID registrazione segnalato per una registrazione riuscita.Run the app and notice that the registration ID is reported for a successful registration.

    Test in Android: registrazione di canali

  2. Immettere un messaggio di notifica da inviare a tutti i dispositivi Android registrati con l'hub.Enter a notification message to be sent to all Android devices that have registered with the hub.

    Test in Android: invio di un messaggio

  3. Premere Send Notification.Press Send Notification. Su tutti i dispositivi che eseguono l'app verrà visualizzata un'istanza di AlertDialog con il messaggio di notifica push.Any devices that have the app running shows an AlertDialog instance with the push notification message. I dispositivi che non eseguono l'app, ma che sono stati registrati in precedenza per le notifiche push, riceveranno una notifica in Android Notification Manager.Devices that don't have the app running but were previously registered for push notifications receive a notification in the Android Notification Manager. Per visualizzare le notifiche, scorrere verso il basso dall'angolo superiore sinistro.The notifications can be viewed by swiping down from the upper-left corner.

    Test in Android: notifiche

Passaggi successiviNext steps

In questa esercitazione è stato usato Firebase Cloud Messaging per inviare notifiche push a dispositivi Android.In this tutorial, you used Firebase Cloud Messaging to push notifications to Android devices. Per informazioni sulle procedure per effettuare il push di notifiche con Google Cloud Messaging, passare all'esercitazione seguente:To learn how to push notifications by using Google Cloud Messaging, advance to the following tutorial: