Configurer une application cliente Firebase Cloud Messaging avec C++

Pour écrire votre application cliente Firebase Cloud Messaging multiplate-forme avec C++, utilisez l'API Firebase Cloud Messaging. Le SDK C++ fonctionne à la fois pour les plates-formes Android et Apple, avec une configuration supplémentaire requise pour chaque plate-forme.

Configurer Firebase et le SDK FCM

Android

  1. Si ce n'est pas encore fait, ajoutez Firebase à votre projet C++.

    • Dans les instructions de configuration associées, consultez les exigences concernant l'appareil et l'application pour utiliser le SDK C++ Firebase, y compris la recommandation d'utiliser CMake pour compiler votre application.

    • Dans le fichier build.gradle de niveau projet, veillez à inclure le dépôt Maven de Google à la fois dans les sections buildscript et allprojects.

  2. Créez un objet d'application Firebase en transmettant l'environnement JNI et l'activité :

    app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);

  3. Définissez une classe qui implémente l'interface firebase::messaging::Listener.

  4. Initialisez FCM en transmettant l'application et un écouteur créé : 

    ::firebase::messaging::Initialize(app, listener);

  5. Les applications qui reposent sur le SDK des services Google Play doivent vérifier la présence d'un APK des services Google Play compatible sur l'appareil avant d'accéder aux fonctionnalités. Pour en savoir plus, consultez la page Vérifier l'APK des services Google Play.

iOS+

  1. Si ce n'est pas encore fait, ajoutez Firebase à votre projet C++. Pour configurer votre projet pour FCM :
    1. Dans le fichier Podfile de votre projet, ajoutez la dépendance FCM : 
      pod 'FirebaseMessaging'
    2. Faites glisser les frameworks firebase.framework et firebase_messaging.framework dans votre projet Xcode à partir du SDK Firebase C++.

  2. Importez votre clé d'authentification d'APN dans Firebase. Si vous ne possédez pas encore de clé d'authentification d'APN, veillez à en créer une dans le Centre des membres pour les développeurs Apple.

    1. Dans la console Firebase, sélectionnez l'icône en forme de roue dentée, puis Paramètres du projet, puis l'onglet Cloud Messaging.

    2. Dans Clés d'authentification d'APN, sous Configuration de l'application iOS, cliquez sur le bouton Importer.

    3. Accédez à l'emplacement où vous avez enregistré votre clé, sélectionnez-la, puis cliquez sur Ouvrir. Ajoutez l'ID de la clé (disponible dans le Apple Developer Member Center) et cliquez sur Importer.

  3. Configurez votre projet Xcode pour activer les notifications push:

    1. Sélectionnez le projet dans la zone du navigateur.
    2. Sélectionnez la cible du projet dans la zone de l'éditeur.

    3. Sélectionnez l'onglet Général dans la zone de l'éditeur.

      1. Faites défiler la page jusqu'à Linked Frameworks and Libraries (Frameworks et bibliothèques associés), puis cliquez sur le bouton + pour ajouter des frameworks.

      2. Dans la fenêtre qui s'affiche, faites défiler la page jusqu'à UserNotifications.framework, cliquez sur cette entrée, puis sur Ajouter.

        Ce framework n'apparaît que dans Xcode 8 et versions ultérieures, et est requis par cette bibliothèque.

    4. Sélectionnez l'onglet Fonctionnalités dans la zone de l'éditeur.

      1. Activez l'option Notifications push.
      2. Faites défiler l'écran jusqu'à Modes d'arrière-plan, puis activez l'option.
      3. Sélectionnez Notifications à distance sous Modes en arrière-plan.

  4. Créez un objet Application Firebase : 

    app = ::firebase::App::Create(::firebase::AppOptions());

  5. Définissez une classe qui implémente l'interface firebase::messaging::Listener.

  6. Initialisez Firebase Cloud Messaging en transmettant l'application et un écouteur créé : 

    ::firebase::messaging::Initialize(app, listener);

Accéder au jeton d'enregistrement de l'appareil

Lors de l'initialisation de la bibliothèque Firebase Cloud Messaging, un jeton d'enregistrement est demandé pour l'instance de l'application cliente. L'application recevra le jeton avec le rappel OnTokenReceived, qui doit être défini dans la classe qui implémente firebase::messaging::Listener.

Si vous souhaitez cibler cet appareil spécifique, vous devez avoir accès à ce jeton.

Remarque concernant la distribution des messages sur Android

Lorsque l'application n'est pas en cours d'exécution et qu'un utilisateur appuie sur une notification, le message n'est pas acheminé par défaut via les rappels intégrés de FCM. Dans ce cas, les charges utiles des messages sont reçues via un Intent utilisé pour démarrer l'application. Pour que FCM transfère ces messages entrants au rappel de la bibliothèque C++, vous devez remplacer la méthode onNewIntent dans votre activité et transmettre Intent à MessageForwardingService.

import com.google.firebase.messaging.MessageForwardingService;

class MyActivity extends Activity {
  private static final String TAG = "MyActvity";

  @Override
  protected void onNewIntent(Intent intent) {
    Log.d(TAG, "A message was sent to this app while it was in the background.");
    Intent message = new Intent(this, MessageForwardingService.class);
    message.setAction(MessageForwardingService.ACTION_REMOTE_INTENT);
    message.putExtras(intent);
    message.setData(intent.getData());
    // For older versions of Firebase C++ SDK (< 7.1.0), use `startService`.
    // startService(message);
    MessageForwardingService.enqueueWork(this, message);
  }
}

Le contenu du champ de notification des messages reçus lorsque l'application est en arrière-plan est utilisé pour renseigner la notification de la barre d'état système, mais ce contenu de notification ne sera pas communiqué à FCM. Autrement dit, Message::notification sera nul.

En résumé :

État de l'application Notification Données Les deux
Premier plan OnMessageReceived OnMessageReceived OnMessageReceived
Contexte Barre d'état système OnMessageReceived Notification: barre d'état du système
Données: dans les extras de l'intent.

Gestion des messages personnalisée sur Android

Par défaut, les notifications envoyées à l'application sont transmises à ::firebase::messaging::Listener::OnMessageReceived, mais dans certains cas, vous pouvez ignorer le comportement par défaut. Pour ce faire sur Android, vous devez écrire des classes personnalisées qui étendent com.google.firebase.messaging.cpp.ListenerService et mettre à jour le AndroidManifest.xml de votre projet.

Remplacez les méthodes ListenerService.

ListenerService est la classe Java qui intercepte les messages entrants envoyés à l'application et les redirige vers la bibliothèque C++. Lorsque l'application est au premier plan (ou lorsqu'elle est en arrière-plan et qu'elle reçoit une charge utile de données uniquement), les messages passent par l'un des rappels fournis dans cette classe. Pour ajouter un comportement personnalisé à la gestion des messages, vous devez étendre le ListenerService par défaut de FCM:

import com.google.firebase.messaging.cpp.ListenerService;

class MyListenerService extends ListenerService {

En remplaçant la méthode ListenerService.onMessageReceived, vous pouvez effectuer des actions en fonction de l'objet RemoteMessage reçu et obtenir les données du message:

@Override
public void onMessageReceived(RemoteMessage message) {
  Log.d(TAG, "A message has been received.");
  // Do additional logic...
  super.onMessageReceived(message);
}

ListenerService propose également quelques autres méthodes moins fréquemment utilisées. Vous pouvez également les remplacer. Pour en savoir plus, consultez la documentation de référence sur FirebaseMessagingService.

@Override
public void onDeletedMessages() {
  Log.d(TAG, "Messages have been deleted on the server.");
  // Do additional logic...
  super.onDeletedMessages();
}

@Override
public void onMessageSent(String messageId) {
  Log.d(TAG, "An outgoing message has been sent.");
  // Do additional logic...
  super.onMessageSent(messageId);
}

@Override
public void onSendError(String messageId, Exception exception) {
  Log.d(TAG, "An outgoing message encountered an error.");
  // Do additional logic...
  super.onSendError(messageId, exception);
}

Mettre à jour AndroidManifest.xml

Une fois vos classes personnalisées écrites, elles doivent être incluses dans le fichier AndroidManifest.xml pour être appliquées. Assurez-vous que le fichier manifeste inclut les outils de fusion en déclarant l'attribut approprié dans la balise <manifest>, comme suit:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.google.firebase.messaging.cpp.samples"
    xmlns:tools="http://schemas.android.com/tools">

Dans l'archive firebase_messaging_cpp.aar, il existe un fichier AndroidManifest.xml qui déclare le ListenerService par défaut de FCM. Ce fichier manifeste est normalement fusionné avec le fichier manifeste spécifique au projet, ce qui permet à ListenerService de s'exécuter. Ce ListenerService doit être remplacé par le service d'écouteur personnalisé. Pour ce faire, supprimez le ListenerService par défaut et ajoutez le service personnalisé, ce qui peut être fait avec les lignes suivantes du fichier AndroidManifest.xml de votre projet:

<service android:name="com.google.firebase.messaging.cpp.ListenerService"
         tools:node="remove" />

<service android:name="com.google.firebase.messaging.cpp.samples.MyListenerService"
         android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT"/>
  </intent-filter>
</service>

Les nouvelles versions du SDK Firebase C++ (à partir de la version 7.1.0) utilisent JobIntentService, ce qui nécessite des modifications supplémentaires dans le fichier AndroidManifest.xml.

<service android:name="com.google.firebase.messaging.MessageForwardingService"
     android:permission="android.permission.BIND_JOB_SERVICE"
     android:exported="false" >
</service>

Empêcher l'initialisation automatique

FCM génère un jeton d'enregistrement pour le ciblage par appareil. Lorsqu'un jeton est généré, la bibliothèque importe l'identifiant et les données de configuration dans Firebase. Si vous souhaitez obtenir une autorisation explicite avant d'utiliser le jeton, vous pouvez empêcher la génération au moment de la configuration en désactivant FCM (et Analytics sur Android). Pour ce faire, ajoutez une valeur de métadonnées à votre Info.plist (et non à votre GoogleService-Info.plist) sur les plates-formes Apple, ou à votre AndroidManifest.xml sur Android:

Android

<?xml version="1.0" encoding="utf-8"?>
<application>
  <meta-data android:name="firebase_messaging_auto_init_enabled"
             android:value="false" />
  <meta-data android:name="firebase_analytics_collection_enabled"
             android:value="false" />
</application>

Swift

FirebaseMessagingAutoInitEnabled = NO

Pour réactiver FCM, vous pouvez effectuer un appel d'environnement d'exécution:

::firebase::messaging::SetTokenRegistrationOnInitEnabled(true);

Une fois définie, cette valeur persiste lors des redémarrages de l'application.

FCM permet d'envoyer des messages contenant un lien profond dans votre application. Pour recevoir des messages contenant un lien profond, vous devez ajouter un nouveau filtre d'intent à l'activité qui gère les liens profonds de votre application. Le filtre d'intent doit détecter les liens profonds de votre domaine. Si vos messages ne contiennent pas de lien profond, cette configuration n'est pas nécessaire. Dans AndroidManifest.xml:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="http"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="https"/>
</intent-filter>

Vous pouvez également spécifier un caractère générique pour rendre le filtre d'intent plus flexible. Exemple :

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="*.example.com" android:scheme="http"/>
  <data android:host="*.example.com" android:scheme="https"/>
</intent-filter>

Lorsque les utilisateurs appuient sur une notification contenant un lien vers le schéma et l'hôte que vous spécifiez, votre application lance l'activité avec ce filtre d'intent pour gérer le lien.

Étapes suivantes

Une fois l'application cliente configurée, vous pouvez envoyer des messages en aval et des messages de thème avec Firebase. Pour en savoir plus, consultez la démonstration de cette fonctionnalité dans l'exemple de démarrage rapide que vous pouvez télécharger, exécuter et consulter.

Pour ajouter un autre comportement plus avancé à votre application, consultez les guides d'envoi de messages à partir d'un serveur d'application:

N'oubliez pas que vous aurez besoin d'une implémentation de serveur pour utiliser ces fonctionnalités.