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

Articolo
07/17/2024

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

Importante

Google smetterà di supportare HTTP legacy FCM il 20 giugno 2024. Per altre informazioni, vedere Hub di notifica di Azure e Migrazione di Google Firebase Cloud Messaging.

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

Avviare Android Studio.
Selezionare File, scegliere New (Nuovo) e quindi New Project (Nuovo progetto).
Nella pagina Choose your project (Scegliere il progetto) selezionare Empty Activity (Attività vuota) e quindi Next (Avanti).
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.

Creare un progetto Firebase che supporta FCM

Accedere alla console di Firebase. Creare un nuovo progetto Firebase se non è già disponibile.
Dopo aver creato il progetto, selezionare Add Firebase to your Android app (Aggiungi Firebase all'app Android).
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.
2. Selezionare Registra l'app.
Selezionare Download google-services.json (Scarica google-services.json), salvare il file nella cartella app del progetto e quindi selezionare Avanti.
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 (<progetto>/<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.
Selezionare Avanti.
Selezionare Ignora questo passaggio.
Nella console di Firebase selezionare il file COG per il progetto. Selezionare quindi Project Settings (Impostazioni progetto).
Se il file google-services.json non è stato scaricato nella cartella app del progetto di Android Studio, è possibile eseguire questa operazione in questa pagina.
Passare alla scheda Cloud Messaging in alto.
Copiare e salvare il valore di Chiave server per un uso successivo. Questo valore viene usato per configurare l'hub.
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.

Configurare un hub

Accedere al portale di Azure.
Scegliere Tutti i servizi dal menu a sinistra.
Digitare Hub di notifica nella casella di testo Filtri 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.
Nella pagina Hub di notifica selezionare Crea sulla barra degli strumenti.
Nella scheda Informazioni di base della pagina hub di notifica seguire questa procedura:
1. In Sottoscrizioneselezionare 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.
5. Esaminare l'opzione Zone di disponibilità. Se si sceglie un'area con zone di disponibilità, la casella di controllo è selezionata per impostazione predefinita. Le zone di disponibilità sono 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.
7. Seleziona Crea.
Una volta completata la distribuzione, selezionare Vai alla risorsa.

Configurare le impostazioni di Firebase Cloud Messaging per l'hub

Nel riquadro a sinistra in Settings (Impostazioni) selezionare Google (GCM/FCM).
Immettere la chiave del server per il progetto FCM salvato in precedenza.
Sulla barra degli strumenti selezionareSave (Salva).
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

In Android Studio selezionare Strumenti nel menu e quindi SDK Manager.
Selezionare la versione di destinazione di Android SDK che viene usata nel progetto. Quindi selezionare Mostra i dettagli del pacchetto.
Selezionare API Google, se non è già installato.
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.
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).
Selezionare OK per chiudere la finestra di dialogo Settings for New Projects (Impostazioni per nuovi progetti).

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

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'
```

Aggiungere il repository seguente dopo la sezione dependencies.

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

Aggiungere il supporto di Google Firebase

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'

Aggiungere il plug-in seguente alla fine del file se non è già presente.
```
apply plugin: 'com.google.gms.google-services'
```
Selezionare Sync Now (Sincronizza ora) sulla barra degli strumenti.

Aggiornare il file AndroidManifest.xml

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

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

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.

Aggiornare questi due segnaposto nel codice seguente per la classe NotificationSettings:
- 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.

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);
        }
    }
}

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;

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;

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;
}

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);
    }
}

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());
}

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);
        }
    });
}

Il metodo ToastNotify usa il controllo "Hello World" TextView per segnalare lo stato e le notifiche in modo persistente nell'app. Nel layout res>layout>activity_main.xml aggiungere l'ID seguente per questo controllo.
```
android:id="@+id/text_hello"
```
Aggiungere quindi una sottoclasse per il ricevitore definito nel file AndroidManifest.xml. Aggiungere al progetto un'altra nuova classe denominata FirebaseService.

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;

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);
         }
    }
}

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"
```
Assicurarsi di disporre di un dispositivo virtuale per l'esecuzione dell'app. Se non è presente, aggiungerne uno nel modo seguente:
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.

Testare la notifica di invio dall'hub di notifica

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

Nella pagina Hub di notifica per l'hub nel portale di Azure selezionare Invio di prova nella sezione Risoluzione dei problemi.
Per Platforms (Piattaforme) selezionare Android.
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.
Osservare i risultati dell'operazione nell'elenco in fondo.
Il messaggio di notifica viene visualizzato nel dispositivo.

Le notifiche push vengono in genere inviate in un servizio back-end come App per dispositivi mobili o ASP.NET usando una libreria compatibile. 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:

App per dispositivi mobili di Azure: per un esempio di come inviare notifiche dal back-end di un'app per dispositivi mobili integrata con Hub di notifica, vedere Aggiungere notifiche push all'app iOS.
ASP.NET: usare Hub di notifica per inviare notifiche push agli utenti.
SDK per Java di Hub di notifica di Azure: vedere Come usare Hub di notifica da Java per l'invio di notifiche da Java. È stato testato in Eclipse per lo sviluppo per Android.
PHP: Come usare Hub di notifica da PHP.

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 generata l'eccezione SERVICE_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 possono generare 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:

Esercitazione: Inviare notifiche push a specifici dispositivi Android

Condividi tramite