Share via


Esercitazione: Inviare notifiche push ai dispositivi Android con Firebase SDK versione 0.6

Questa esercitazione illustra come usare Hub di notifica di Azure e Firebase Cloud Messaging (FCM) SDK versione 0.6 per inviare notifiche push a un'applicazione Android. In questa esercitazione verrà creata un'app Android vuota che riceve notifiche push tramite Firebase Cloud Messaging (FCM).

Le funzionalità principali per l'integrazione di Hub di notifica di Azure con Firebase Cloud Messaging (FCM) v1 sono pronte per i test. Come promemoria, Google smetterà di supportare HTTP legacy FCM il 20 giugno 2024, quindi è necessario eseguire la migrazione delle applicazioni e dei payload di notifica al nuovo formato prima di allora. Tutti i metodi di onboarding saranno pronti per la migrazione entro il 1° marzo 2024.

Per semplificare questa transizione, ti invitiamo a partecipare al programma di anteprima e testare il processo di onboarding FCM v1 per le API REST nel mese di febbraio 2024. L'anteprima offre l'accesso anticipato alle nuove funzionalità e funzionalità, nonché all'opportunità di fornire commenti e suggerimenti e segnalare eventuali problemi.

Se sei interessato a partecipare al programma di anteprima, contattaci via e-mail entro il 25 gennaio 2024. Si risponderà con le istruzioni su come eseguire l'onboarding in FCM v1 usando il portale di Azure o l'API REST. Riceverai anche un collegamento alla documentazione e ai canali di supporto.

Concetti relativi a FCM v1

  • Sarà supportato un nuovo tipo di piattaforma, denominato FCM v1.
  • Nuove API, credenziali, registrazioni e installazioni verranno usate per FCM v1.

Nota

La piattaforma FCM esistente viene definita legacy FCM in questo articolo.

Passaggi di migrazione (anteprima)

L'API legacy Firebase Cloud Messaging (FCM) sarà deprecata entro luglio 2024. È possibile iniziare la migrazione dal protocollo HTTP legacy a FCM v1 il 1° marzo 2024. È necessario completare la migrazione entro giugno 2024.

Importante

Al momento non è necessaria alcuna azione; è possibile consultare qui per altre istruzioni.

In caso di domande o problemi, contattare il team di supporto.

Per eseguire la migrazione da FCM legacy a FCM v1, ecco cosa si può prevedere:

  1. Specificare le credenziali per FCM v1: è necessario fornire le credenziali FCM v1 per configurare le notifiche.
  2. Aggiornare l'app client per avviare la registrazione come dispositivi FCM v1: una volta pronti per iniziare a supportare i dispositivi FCMv1, aggiornare l'app client in modo che tutti i nuovi dispositivi inizino a eseguire la registrazione come FCM v1 anziché come legacy FCM. Ciò garantisce che le notifiche vengano inviate agli utenti in modo appropriato una volta deprecata la versione legacy di FCM.
  3. Aggiornare l'app server per inviare notifiche a FCM v1: dopo aver completato i passaggi precedenti, è possibile iniziare a inviare notifiche usando la nuova API.
  4. Interrompere l'invio di notifiche alla versione legacy di FCM: una volta registrati tutti i dispositivi esistenti come dispositivi FCM v1, interrompere l'invio di notifiche alla versione legacy di FCM. A questo punto è consigliabile inviare tutte le notifiche esclusivamente a FCM v1 ed è necessario eseguire la migrazione completa.

Il codice completo per questa esercitazione può essere scaricato da GitHub.

In questa esercitazione vengono completati i passaggi seguenti:

  • Creare un progetto di Android Studio.
  • Creare un progetto Firebase che supporta Firebase Cloud Messaging.
  • Creare un hub.
  • Connettere l'app all'hub.
  • Test dell'app.

Prerequisiti

Per completare l'esercitazione, è necessario disporre di un account Azure attivo. Se non si dispone di un account, è possibile creare un account di valutazione gratuita in pochi minuti. Per informazioni dettagliate, vedere Versione di valutazione gratuita di Azure.

Sono necessari anche gli elementi seguenti:

  • Ultima versione di Android Studio
  • Android 2.3 o versione successiva per Firebase Cloud Messaging
  • Google Repository revisione 27 o successiva per Firebase Cloud Messaging
  • Google Play Services 9.0.2 o versione successiva per Firebase Cloud Messaging

Il completamento di questa esercitazione costituisce un prerequisito per tutte le altre esercitazioni su Hub di notifica per app Android.

Creare un progetto di Android Studio

  1. Avviare Android Studio.
  2. Selezionare File, scegliere New (Nuovo) e quindi New Project (Nuovo progetto).
  3. Nella pagina Choose your project (Scegliere il progetto) selezionare Empty Activity (Attività vuota) e quindi Next (Avanti).
  4. Nella pagina Configura il progetto seguire questa procedura:
    1. Immettere un nome per l'applicazione.

    2. Specificare un percorso in cui salvare i file del progetto.

    3. Selezionare Fine.

      Configure your project)

Creare un progetto Firebase che supporta FCM

  1. Accedere alla console di Firebase. Creare un nuovo progetto Firebase se non è già disponibile.

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

    Add Firebase to your Android app

  3. Nella pagina Aggiungere Firebase all'app Android seguire questa procedura:

    1. Per Android package name (Nome pacchetto Android), copiare il valore di applicationId nel file build.gradle dell'applicazione. In questo esempio è com.fabrikam.fcmtutorial1app.

      Specify the package name

    2. Selezionare Registra l'app.

  4. Selezionare Download google-services.json (Scarica google-services.json), salvare il file nella cartella app del progetto e quindi selezionare Avanti.

    Download google-services.json

  5. Apportare le seguenti modifiche di configurazione al progetto in Android Studio.

    1. Nel file project-level build.gradle (<project>/build.gradle) aggiungere l'istruzione seguente alla sezione dependencies.

      classpath 'com.google.gms:google-services:4.0.1'
      
    2. Nel file build.gradle a livello di app (<project>/<app-module>/build.gradle) aggiungere le istruzioni seguenti alla sezione dependencies .

      implementation 'com.google.firebase:firebase-core:16.0.8'
      implementation 'com.google.firebase:firebase-messaging:17.3.4'
      
    3. Aggiungere la riga seguente alla fine del file app-level build.gradle dopo la sezione dependencies.

      apply plugin: 'com.google.gms.google-services'
      
    4. Selezionare Sincronizza ora sulla barra degli strumenti.

      build.gradle configuration changes

  6. Selezionare Avanti.

  7. Selezionare Ignora questo passaggio.

    Skip the last step

  8. Nella console di Firebase selezionare il file COG per il progetto. Selezionare quindi Project Settings (Impostazioni progetto).

    Select Project Settings

  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.

  10. Passare alla scheda Cloud Messaging in alto.

  11. Copiare e salvare il valore di Chiave server per un uso successivo. Questo valore viene usato per configurare l'hub.

  12. Se nella scheda Firebase Cloud Messaging non viene visualizzata una chiave server, seguire questa procedura aggiuntiva.

    1. Fare clic sul menu a tre punti dell'intestazione "Cloud Messaging API (Legacy) 🚫 Disabled"
    2. Seguire il collegamento offerto a "Gestire l'API in Google Cloud Console".
    3. Nella console google cloud premere il pulsante per abilitare l'API googlecloudmessaging.
    4. Attendere qualche minuto.
    5. Tornare alla scheda Cloud Messaging del progetto console firebase e aggiornare la pagina.
    6. Vedere che l'intestazione dell'API Messaggistica cloud è stata modificata in "Cloud Messaging API (Legacy) Enabled" (API di messaggistica cloud (legacy) ✅ abilitata" e ora mostra una chiave server.

    Screenshot showing the Enable Cloud Messaging API (Legacy) tab.

Configurare un hub

  1. Accedere al portale di Azure.

  2. Scegliere Tutti i servizi dal menu a sinistra. A screenshot showing select All Services for an existing namespace.

  3. Digitare Hub di notifica nella casella di testo Filtra servizi. Selezionare l'icona a forma di stella accanto al nome del servizio per aggiungere il servizio alla sezione PREFERITI nel menu a sinistra. Selezionare Hub di notifica.

    A screenshot showing how to filter for notification hubs.

  4. Nella pagina Hub di notifica selezionare Crea sulla barra degli strumenti.

    A screenshot showing how to create a new notification hub.

  5. Nella scheda Informazioni di base della pagina Hub di notifica seguire questa procedura:

    1. In Sottoscrizione selezionare il nome della sottoscrizione di Azure che si vuole usare e quindi selezionare un gruppo di risorse esistente o crearne uno nuovo.

    2. Immettere un nome univoco per il nuovo spazio dei nomi in Dettagli spazio dei nomi.

    3. Uno spazio dei nomi contiene uno o più hub di notifica, quindi digitare un nome per l'hub in Dettagli hub di notifica.

    4. Selezionare un valore nell'elenco a discesa Posizione. Questo valore specifica la posizione in cui creare l'hub.

      Screenshot showing notification hub details.

    5. Esaminare l'opzione zone di disponibilità. Se si sceglie un'area con zone di disponibilità, la casella di controllo è selezionata per impostazione predefinita. zone di disponibilità è una funzionalità a pagamento, quindi viene aggiunta una tariffa aggiuntiva al livello.

    6. Scegliere un'opzione di ripristino di emergenza: Nessuna, Area di ripristino abbinata o Area di ripristino flessibile. Se si sceglie Area di ripristino abbinata, viene visualizzata l'area di failover. Se si seleziona Area di ripristino flessibile, usare l'elenco a discesa per scegliere tra un elenco di aree di ripristino.

      Screenshot showing availability zone details.

    7. Seleziona Crea.

  6. Al termine della distribuzione, selezionare Vai alla risorsa.

Configurare le impostazioni di Firebase Cloud Messaging per l'hub

  1. Nel riquadro a sinistra in Settings (Impostazioni) selezionare Google (GCM/FCM).

  2. Immettere la chiave del server per il progetto FCM salvato in precedenza.

  3. Sulla barra degli strumenti selezionareSave (Salva).

    Azure Notification Hub - Google (FCM)

  4. Nella sezione degli avvisi del portale di Azure viene visualizzato un messaggio che indica che l'hub è stato aggiornato. Il pulsante Save (Salva) è disabilitato.

L'hub è ora configurato per l'uso di 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.

Connettere l'app all'hub di notifica

Aggiungere Google Play Services al progetto

  1. In Android Studio selezionare Strumenti nel menu e quindi SDK Manager.

  2. Selezionare la versione di destinazione di Android SDK che viene usata nel progetto. Quindi selezionare Mostra i dettagli del pacchetto.

    Android SDK Manager - select target version

  3. Selezionare API Google, se non è già installato.

    Android SDK Manager - Google APIs selected

  4. Passare alla scheda SDK Tools (Strumenti SDK). Se Google Play Services non è già stato installato, selezionare Google Play Services come illustrato nell'immagine seguente. Selezionare Applica per installarlo. Prendere nota del percorso dell'SDK per l'uso in un passaggio successivo.

    Android SDK Manager - Google Play Services selected

  5. Se viene visualizzata la finestra di dialogo Confirm Change (Conferma modifica), selezionare OK. Il programma di installazione componenti installa i componenti richiesti. Al termine dell'installazione dei componenti, selezionare Finish (Fine).

  6. Selezionare OK per chiudere la finestra di dialogo Settings for New Projects (Impostazioni per nuovi progetti).

  7. Aprire il file AndroidManifest.xml e quindi aggiungere il tag seguente al tag dell'applicazione.

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

Aggiungere le librerie di Hub di notifica di Azure

  1. Nel file Build.Gradle per l'app aggiungere le righe seguenti nella sezione dependencies.

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

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

Aggiungere il supporto di Google Firebase

  1. Nel file Build.Gradle per l'app aggiungere le righe seguenti nella sezione dependencies se non sono già presenti.

    implementation 'com.google.firebase:firebase-core:16.0.8'
    implementation 'com.google.firebase:firebase-messaging:17.3.4'
    implementation 'com.google.firebase:firebase-iid:21.1.0'
    
  2. Aggiungere il plug-in seguente alla fine del file se non è già presente.

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

Aggiornare il file AndroidManifest.xml

  1. Dopo aver ricevuto il token di registrazione di FCM, usarlo per la registrazione in Hub di notifica di Azure. La registrazione viene supportata in background mediante un servizio IntentService denominato RegistrationIntentService. Il servizio aggiorna anche il token di registrazione di FCM. 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.

    Aggiungere la definizione del servizio seguente al file AndroidManifest.xml, all'interno del tag <application> .

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

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

Aggiungi codice

  1. Nella visualizzazione del progetto espandere 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). Immettere Notification Settings come nome e quindi scegliere OK.

    Assicurarsi di aggiornare questi due segnaposto nel codice seguente per la NotificationSettings classe :

    • HubListenConnectionString: stringa di connessione DefaultListenAccessSignature per l'hub. È possibile copiare la stringa di connessione facendo clic su Criteri di accesso nell'hub nel portale di Azure.

    • HubName: usare il nome dell'hub visualizzato nella pagina dell'hub nel portale di Azure.

      NotificationSettings :

      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.

  2. Aggiungere al progetto un'altra nuova classe denominata RegistrationIntentService. La classe implementa l'interfaccia IntentService. La classe gestisce anche l'aggiornamento del token di FCM e la registrazione nell'hub di notifica.

    Usare il codice seguente per la classe.

    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", "")).equals(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.

    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. Questi campi vengono usati per verificare la disponibilità di Google Play Services come consigliato da 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.

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

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

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

    @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. Nel layout res>layout>activity_main.xml aggiungere l'ID seguente per questo controllo.

    android:id="@+id/text_hello"
    

    Screenshot that shows the android:id=

  10. Aggiungere quindi una sottoclasse per il ricevitore definito nel file AndroidManifest.xml. Aggiungere al progetto un'altra nuova classe denominata FirebaseService.

  11. Aggiungere le istruzioni import seguenti all'inizio di 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.

    Questo codice esegue l'override del metodo onMessageReceived e segnala le notifiche ricevute. Invia anche la notifica push al gestore delle notifiche di Android usando il metodo sendNotification(). Chiamare il metodo sendNotification() quando l'app non è in esecuzione e viene ricevuta una notifica.

    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. Se si riceve un errore riguardo all'icona ic_launcher, rimuovere l'istruzione seguente dal file AndroidManifest.xml:

        android:icon="@mipmap/ic_launcher"
    
  14. Assicurarsi di disporre di un dispositivo virtuale per l'esecuzione dell'app. Se non è presente, aggiungerne uno nel modo seguente:

    1. Open device manager
    2. Create virtual device
  15. Eseguire l'app nel dispositivo selezionato e verificare che venga registrata correttamente nell'hub.

    Nota

    La registrazione può non riuscire durante l'avvio iniziale, fino a quando non viene chiamato il metodo onTokenRefresh() del servizio Instance ID. L'aggiornamento deve avviare una registrazione corretta con l'hub di notifica.

    Device registration successful

Testare la notifica di invio dall'hub di notifica

È possibile inviare notifiche push dal portale di Azure eseguendo questi passaggi:

  1. Nella pagina Hub di notifica per l'hub nel portale di Azure selezionare Invio di prova nella sezione Risoluzione dei problemi.

  2. Per Platforms (Piattaforme) selezionare Android.

  3. Selezionare Invia. Non verrà visualizzata alcuna notifica nel dispositivo Android, perché nel dispositivo non è stata ancora eseguita l'app per dispositivi mobili. Dopo aver eseguito l'app per dispositivi mobili, selezionare di nuovo il pulsante Invia per visualizzare il messaggio di notifica.

  4. Osservare i risultati dell'operazione nell'elenco in fondo.

    Azure Notification Hubs - Test Send

  5. Il messaggio di notifica viene visualizzato nel dispositivo.

    Notification message on device

Le notifiche push vengono in genere inviate in un servizio back-end come App per dispositivi mobili o ASP.NET usando una libreria compatibile. Se non è disponibile una libreria per il back-end è anche possibile usare direttamente l'API REST per inviare messaggi di notifica.

Di seguito è riportato un elenco di altre esercitazioni, che è possibile esaminare per l'invio di notifiche:

Eseguire l'app per dispositivi mobili nell'emulatore

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. Se l'immagine non supporta le API Google native, è possibile che venga visualizzata l'eccezione edizione Standard RVICE_NOT_AVAILABLE.

Assicurarsi anche di avere aggiunto l'account Google all'emulatore in esecuzione in Impostazioni>Account. In caso contrario, i tentativi di registrazione con FCM potrebbero causare l'eccezione AUTHENTICATION_FAILED .

Passaggi successivi

In questa esercitazione è stato usato Firebase Cloud Messaging per trasmettere notifiche a tutti i dispositivi Android registrati nel servizio. Per informazioni sulle procedure per eseguire il push di notifiche a dispositivi specifici, passare all'esercitazione seguente: