Tutoriel : Envoyer des notifications Push à des appareils Android à l’aide du SDK Firebase version 0.6

Article
03/10/2024

Ce tutoriel vous montre comment utiliser Azure Notification Hubs et le SDK Firebase Cloud Messaging (FCM) version 0.6 pour envoyer des notifications Push à une application Android. Dans ce didacticiel, vous allez créer une application Android vide qui reçoit des notifications Push à l’aide de Firebase Cloud Messaging (FCM).

Important

Google cessera de prendre en charge le protocole HTTP hérité FCM le 20 juin 2024. Pour plus d’informations, consultez Azure Notification Hubs et la migration de Google Firebase Cloud Messaging.

Vous pouvez télécharger le code généré pour ce didacticiel à partir de GitHub.

Dans ce tutoriel, vous effectuez les étapes suivantes :

Créer un projet Android Studio.
Créer un projet qui prend en charge Firebase Cloud Messaging.
Créer un hub.
Connecter votre application au hub.
Tester l'application.

Prérequis

Pour suivre ce didacticiel, vous avez besoin d'un compte Azure actif. Si vous ne possédez pas de compte, vous pouvez créer un compte d’évaluation gratuit en quelques minutes. Pour plus d’informations, consultez Essai gratuit Azure.

Vous devez également disposer des éléments suivants :

Dernière version d’Android Studio
Android 2.3 ou version ultérieure pour Firebase Cloud Messaging
La révision 27 ou ultérieure du référentiel Google est requise pour Firebase Cloud Messaging
Google Play Services 9.0.2 ou version ultérieure pour Firebase Cloud Messaging

Vous devez suivre ce didacticiel avant tous les autres didacticiels Notification Hubs pour les applications Android.

Créer un projet Android Studio

Lancez Android Studio.
Sélectionnez File (Fichier), pointez sur New (Nouveau), puis sélectionnez New Project (Nouveau projet).
Dans la page Choose your project (Choisir votre projet), sélectionnez Empty Activity (Activité vide), puis sélectionnez Next (Suivant).
Dans la page Configure your project (Configurer votre projet), procédez comme suit :
1. Entrez un nom pour l’application.
2. Spécifiez un emplacement où enregistrer les fichiers du projet.
3. Sélectionnez Terminer.

Créer un projet qui prend en charge FCM

Connectez-vous à la console Firebase. Créer un nouveau projet Firebase si vous n’en avez pas encore.
Une fois le projet créé, sélectionnez Add Firebase to your Android app (Ajouter Firebase à votre application Android).
Dans la page Add Firebase to your Android app (Ajouter Firebase à votre application Android), procédez comme suit :
1. Pour le Nom de package Android, copiez la valeur de votre applicationId dans le fichier build.gradle de votre application. Dans cet exemple, il s’agit de com.fabrikam.fcmtutorial1app.
2. Sélectionnez Inscrire une application.
Sélectionnez Télécharger google-services.json, enregistrez le fichier dans le dossier app de votre projet, puis sélectionnez Suivant.
Modifiez la configuration comme suit à votre projet dans Android Studio.
1. Dans votre fichier build.gradle au niveau du projet (<project>/build.gradle), ajoutez l’instruction suivante dans la section dependencies.
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Dans votre fichier build.gradle au niveau de l’application (<projet>/<module_application>/build.gradle), ajoutez les instructions suivantes dans la section dependencies.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Ajoutez la ligne suivante à la fin du fichier build.gradle au niveau de l’application après la section dependencies.
```
apply plugin: 'com.google.gms.google-services'
```
4. Sélectionnez Synchroniser maintenant dans la barre d’outils.
Cliquez sur Suivant.
Sélectionnez Ignorer cette étape.
Dans la console Firebase, sélectionnez la roue dentée associée à votre projet. Ensuite, sélectionnez Project Settings (Paramètres du projet).
Si vous n’avez pas encore téléchargé le fichier google-services.json dans le dossier application de votre projet Android Studio, vous pouvez le faire à partir de cette page.
Basculez vers l’onglet Messagerie cloud en haut.
Copiez et enregistrez la clé du serveur pour une utilisation ultérieure. Vous utilisez cette valeur pour configurer votre hub.
Si vous ne voyez pas de clé de serveur sous l’onglet Firebase Cloud Messaging, procédez comme suit.
1. Cliquez sur le menu à trois points de l’en-tête « API Cloud Messaging (hérité) 🚫 Désactivé »
2. Suivez le lien proposé pour « Gérer l’API dans Google Cloud Console ».
3. Dans google cloud console, appuyez sur le bouton pour activer l’API googlecloudmessaging.
4. Patientez quelques minutes.
5. Retournez à l’onglet Cloud Messaging de votre projet de console firebase, puis actualisez la page.
6. Vérifiez que l’en-tête de l’API Cloud Messaging a changé en « API Cloud Messaging (hérité) ✅ Activé » et affiche maintenant une clé de serveur.

Configurer un Hub

Connectez-vous au portail Azure.
Sélectionnez Tous les services dans le menu de gauche.
Saisissez Notification Hubs dans la zone de texte Services de filtre. Sélectionnez l’icône d’étoile en regard du nom du service pour l’ajouter à la section FAVORIS dans le menu de gauche. Sélectionnez Notification Hubs.
Dans la page Notification Hubs, sélectionnez Créer dans la barre d’outils.
Sous l’onglet Informations de base de la page Notification Hub, effectuez les étapes suivantes :
1. Dans Abonnement, sélectionnez le nom de l’abonnement Azure que vous souhaitez utiliser, puis sélectionnez un groupe de ressources existant ou créez-en un.
2. Entrez un nom unique pour le nouvel espace de noms dans Détails de l’espace de noms.
3. Un espace de noms contient un ou plusieurs hubs de notification, donc tapez un nom pour le hub dans Détails du hub de notification.
4. Sélectionnez une valeur dans la zone de liste déroulante Emplacement. Cette valeur spécifie l’emplacement où vous voulez créer le hub.
5. Examinez l’option Zones de disponibilité. Si vous avez choisi une région contenant des zones de disponibilité, la case à cocher est sélectionnée par défaut. Les zones de disponibilité étant une fonctionnalité payante, des frais supplémentaires sont ajoutés à votre niveau.
6. Choisissez une option de Récupération d’urgence : Aucune, Région de récupération jumelée ou Région de récupération flexible. Si vous choisissez Région de récupération jumelée, la région de basculement s’affiche. Si vous sélectionnez Région de récupération flexible, utilisez la liste déroulante pour choisir parmi une liste de régions de récupération.
7. Sélectionnez Create (Créer).
Une fois le déploiement terminé, sélectionnez Accéder à la ressource.

Configurer les paramètres de Firebase Cloud Messaging pour le hub

Dans le volet gauche, sous Settings (Paramètres), sélectionnez Google (GCM/FCM) .
Entrez la clé serveur pour le projet FCM que vous avez enregistré précédemment.
Dans la barre d’outils, sélectionnez Enregistrer.
Le portail Azure affiche un message dans les alertes, indiquant que le hub a bien été mis à jour. Le bouton Enregistrer est désactivé.

Votre hub est désormais configuré pour fonctionner avec Firebase Cloud Messaging. Vous disposez également des chaînes de connexion nécessaires pour envoyer des notifications à un appareil et inscrire une application pour recevoir des notifications.

Connexion de votre application au hub de notification

Ajout de services Google Play au projet

Dans Android Studio, sélectionnez Outils dans le menu, puis SDK Manager.
Sélectionnez la version cible du Kit de développement logiciel (SDK) Android qui est utilisé dans votre projet. Puis sélectionnez Afficher les détails du package.
Sélectionnez API Google, si elles ne sont pas déjà installées.
Basculez vers l’onglet SDK Tools. Si vous n’avez pas déjà installé un service Google Play, sélectionnez Google Play Services comme indiqué dans l’image suivante. Sélectionnez ensuite Appliquer pour procéder à l’installation. Notez le chemin du Kit de développement logiciel (SDK). Vous l’utiliserez à une étape suivante.
Si la boîte de dialogue de confirmation de la modification s’affiche, sélectionnez OK. Le programme d’installation installe les composants demandés. Sélectionnez Terminer une fois que les composants sont installés.
Sélectionnez OK pour fermer la boîte de dialogue Paramètres pour les nouveaux projets.

Ouvrez le fichier AndroidManifest.xml, puis ajoutez la balise suivante à la balise application.

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

Ajoutez des bibliothèques Azure Notification Hubs

Dans la section dependencies du fichier Build.Gradle pour l’application, ajoutez les lignes suivantes.
```
implementation 'com.microsoft.azure:notification-hubs-android-sdk:0.6@aar'
```

Ajoutez le référentiel suivant après la section dépendances.

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

Ajouter la prise en charge de Google Firebase

Dans la section dependencies du fichier Build.Gradle pour l’application, ajoutez les lignes suivantes si elles n’y figurent pas.

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'

Ajoutez le plug-in suivant à la fin du fichier s’il n’y figure pas encore.
```
apply plugin: 'com.google.gms.google-services'
```
Sélectionnez Synchroniser maintenant dans la barre d’outils.

Mettre à jour le fichier AndroidManifest.xml

Après avoir reçu votre jeton d’inscription FCM, vous l’utilisez pour vous inscrire auprès d’Azure Notification Hub. Effectuez cette inscription en arrière-plan à l’aide d’un élément IntentService nommé RegistrationIntentService. Ce service actualise également votre jeton d’inscription FCM. Vous créez également une classe nommée FirebaseService en tant que sous-classe de FirebaseMessagingService et vous substituez la méthode onMessageReceived pour recevoir et gérer les notifications.

Ajoutez la définition de service suivante au fichier AndroidManifest.xml, dans la balise <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>
```

Ajoutez les autorisations nécessaires suivantes liées à FCM sous la balise </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" />

Ajout de code

Dans la vue du projet, développez app>src>main>java. Cliquez avec le bouton droit sur le dossier de votre package sous java, sélectionnez Nouveau, puis Classe Java. Entrez NotificationSettings pour le nom, puis sélectionnez OK.

Veillez à mettre à jour ces deux espaces réservés dans le code suivant pour la classe NotificationSettings :
- HubListenConnectionString : chaîne de connexion DefaultListenAccessSignature de votre hub. Vous pouvez copier cette chaîne de connexion en cliquant sur Stratégies d’accès dans votre hub sur le Azure portal.
- HubName : utilisez le nom qui s’affiche dans la page du hub sur le Azure portal.
  
  NotificationSettings code :
```
public class NotificationSettings {
    public static String HubName = "<Your HubName>";
    public static String HubListenConnectionString = "<Enter your DefaultListenSharedAccessSignature connection string>";
}
```
  Important
  
  Entrez le nom et la valeur DefaultListenSharedAccessSignature pour votre hub avant de continuer.

Ajoutez à votre projet une autre nouvelle classe nommée RegistrationIntentService. Cette classe implémente l’interface IntentService. Elle gère également l’actualisation du jeton GCM et l’inscription auprès du hub de notification.

Utilisez le code suivant pour cette 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);
        }
    }
}

Dans la classe MainActivity, ajoutez les instructions import suivantes au-dessus de la déclaration de la 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;

Ajoutez les membres suivants en haut de la classe. Vous utilisez ces champs pour vérifier la disponibilité des Google Play Services comme recommandé par 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;

Dans la classe MainActivity, ajoutez la méthode suivante pour vérifier la disponibilité de 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;
}

Dans la classe MainActivity, ajoutez le code suivant pour rechercher Google Play Services avant d’appeler le service IntentService afin d’obtenir votre jeton d’inscription FCM et de vous inscrire auprès de votre hub :

public void registerWithNotificationHubs()
{
    if (checkPlayServices()) {
        // Start IntentService to register this application with FCM.
        Intent intent = new Intent(this, RegistrationIntentService.class);
        startService(intent);
    }
}

Dans la méthode OnCreate de la classe MainActivity, ajoutez le code suivant pour lancer le processus d’inscription lorsque l’activité est créée :

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    mainActivity = this;
    registerWithNotificationHubs();
    FirebaseService.createChannelAndHandleNotifications(getApplicationContext());
}

Pour vérifier l’état de l’application et afficher un rapport dans votre application, ajoutez à MainActivity les méthodes supplémentaires suivantes :

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

La méthode ToastNotify utilise le contrôle « Hello World »TextView pour afficher en permanence un rapport d’état et des notifications dans l’application. Dans votre disposition res>layout>activity_main.xml, ajoutez l’ID suivant pour ce contrôle.
```
android:id="@+id/text_hello"
```
Ajoutez ensuite une sous-classe pour le destinataire que vous avez défini dans le fichier AndroidManifest.xml. Ajoutez à votre projet une autre nouvelle classe nommée FirebaseService.

Ajoutez les instructions d’importation suivantes au-dessus de 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;

Ajoutez le code suivant pour la classe FirebaseService afin d’en faire une sous-classe de FirebaseMessagingService.

Ce code substitue la méthode onMessageReceived et signale les notifications reçues. Il envoie également la notification Push au gestionnaire de notifications Android en utilisant la méthode sendNotification(). Appelez la méthode sendNotification() quand l’application n’est pas en cours d’exécution et qu’une notification est reçue.

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

Dans Android Studio, dans la barre de menus, sélectionnez Build>Rebuild Project pour vérifier que votre code ne contient pas d’erreur. Si vous recevez une erreur liée à l’icône ic_launcher, supprimez du fichier AndroidManifest.xml l’instruction suivante :
```
    android:icon="@mipmap/ic_launcher"
```
Vérifiez que vous disposez d’un appareil virtuel pour l’exécution de l’application. Si vous n’en avez pas, ajoutez-en un de la façon suivante :
Exécutez l’application sur l’appareil de votre choix, puis vérifiez que son inscription s’est correctement effectuée auprès du hub.

Notes

L’inscription peut échouer lors du lancement initial jusqu’à ce que la méthode onTokenRefresh() du service d’ID d’instance soit appelée. L’actualisation doit initier une inscription réussie auprès du hub de notification.

Test de l’envoi d’une notification à partir du hub de notification

Vous pouvez envoyer des notifications Push à partir du Azure portal en procédant comme suit :

Sur le portail Azure, dans la page Hub de notification de votre hub, dans la section Dépannage, sélectionnez Envoi de test.
Pour les plateformes, sélectionnez Android.
Sélectionnez Envoyer. Vous ne voyez pas encore de notification sur l’appareil Android parce que vous n’avez pas exécuté l’application mobile sur celui-ci. Après avoir exécuté l’application mobile, sélectionnez de nouveau le bouton Envoyer pour voir le message de notification.
Consultez le résultat de l’opération dans la liste en bas.
Vous voyez le message de notification sur votre appareil.

Les notifications Push sont normalement envoyées dans un service principal tel que Mobile Apps ou ASP.NET à l’aide d’une bibliothèque compatible. Si aucune bibliothèque n’est disponible pour votre backend, vous pouvez également utiliser l’API REST directement pour envoyer des messages de notification.

La liste ci-dessous répertorie certains autres didacticiels, que vous pouvez consulter pour envoyer des notifications :

Azure Mobile Apps : pour découvrir un exemple de la procédure d’envoi de notifications à partir d’un serveur principal Mobile Apps intégré à Notification Hubs, consultez l’article Ajout de notifications Push à votre application iOS.
ASP.NET : Utilisation de Notification Hubs pour envoyer des notifications aux utilisateurs.
Kit de développement logiciel (SDK) Java pour Azure Notification Hub : consultez Utilisation de Notification Hubs à partir de Java pour envoyer des notifications à partir de Java. Il a été testé dans Eclipse pour le développement Android.
PHP : Utilisation de Notification Hubs à partir de PHP.

Exécuter l’application mobile sur un émulateur

Avant de tester les notifications Push dans un émulateur, vérifiez que votre image d’émulateur prend en charge le niveau d’API Google que vous avez choisi pour votre application. Si votre image ne prend pas en charge les API Google natives, vous pouvez obtenir l’exception SERVICE_NOT_AVAILABLE.

Vérifiez aussi que vous avez ajouté votre compte Google à l’émulateur en cours d’exécution sous Paramètres>Comptes. Dans le cas contraire, vos tentatives d’inscription auprès de FCM risquent d’entraîner la levée de l’exception AUTHENTICATION_FAILED.

Étapes suivantes

Dans ce didacticiel, vous avez utilisé Firebase Cloud Messaging pour diffuser des notifications à tous les appareils Android inscrits auprès du service. Pour savoir comment envoyer des notifications Push à des appareils spécifiques, passez au didacticiel suivant :

Tutoriel : Notifications Push sur des appareils Android spécifiques