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

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.
  • Testare l'app.

Prerequisiti

Per completare l'esercitazione, è necessario disporre di un account Azure attivo. Se non si dispone di un account Azure, è possibile creare un account di valutazione gratuito in pochi minuti. Per informazioni dettagliate, vedere la pagina relativa alla 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 Configure your project (Configurare il progetto) completare questi passaggi:
    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 Add Firebase to your Android app (Aggiungi 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 <.

      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.

Configurare un hub

  1. Accedere al portale di Azure.

  2. Scegliere Tutti i servizi dal menu a sinistra e quindi selezionare Hub di notifica nella sezione Dispositivi mobili. Selezionare l'icona a forma di stella accanto al nome del servizio per aggiungere il servizio alla sezione PREFERITI nel menu a sinistra. Dopo aver aggiunto Hub di notifica a PREFERITI, selezionarlo nel menu a sinistra.

    Azure portal - select Notification Hubs

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

    Notification Hubs - Add toolbar button

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

    1. In Sottoscrizioneselezionare il nome della sottoscrizione di Azure da 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. In caso contrario, selezionare uno spazio dei nomi esistente nell'elenco a discesa.

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

    5. Selezionare Crea.

      Azure portal - set notification hub properties

  5. Selezionare Notifiche (icona a forma di campanello) e quindi selezionare Vai alla risorsa. È anche possibile aggiornare l'elenco nella pagina Hub di notifica e selezionare l'hub.

    Azure portal - go to resource

  6. Selezionare Criteri di accesso dall'elenco. Prendere nota delle due stringhe di connessione disponibili. Sono necessarie in un secondo momento per gestire le notifiche push.

    Importante

    Non usare il criterio DefaultFullSharedAccessSignature nell'applicazione. Deve essere usato solo nel back-end.

    Azure portal - notification hub connection strings

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. Se lo strumento Google Play Services non è già installato, fare clic su Google Play Services come illustrato nell'immagine di seguito. 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'
    
  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" />
    

Aggiungere codice

  1. Nella visualizzazione Project espandere appsrcmainjava. 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.

    Aggiornare questi tre segnaposto nel codice seguente per la classe NotificationSettings:

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

    • HubName: Usare il nome dell'hub visualizzato nella pagina dell'hub del Azure portal.

      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 ToastNotify metodo usa il controllo ToastNotify per segnalare lo stato e TextView le notifiche in modo permanente nell'app. Nel layout resactivity_main.xml layout aggiungere l'ID seguente per il 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. Nella Android Studio menu selezionare Compila Ricompila Project per assicurarsi che non siano presenti errori nel codice. 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 Azure portal 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 Send (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 SERVICE_NOT_AVAILABLE eccezione.

Assicurarsi anche di aver aggiunto l'account Google all'emulatore in esecuzione in Impostazioniaccount. In caso contrario, i tentativi di registrazione con FCM potrebbero generare l'AUTHENTICATION_FAILED eccezione.

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: