Premiers pas avec Firebase Cloud Messaging dans les applications C++

Ce guide explique comment commencer à utiliser Firebase Cloud Messaging dans vos applications clientes C++ afin de pouvoir envoyer des messages de manière fiable.

Pour écrire votre application cliente multiplate-forme Firebase Cloud Messaging avec C++, utilisez l' Firebase Cloud Messaging API. Le SDK C++ fonctionne sur les plates-formes Android et Apple, mais une configuration supplémentaire est requise pour chaque plate-forme. Pour en savoir plus sur le fonctionnement du SDK C++ pour iOS et Android avec FCM, consultez Comprendre Firebase pour C++.

Configurer Firebase et le FCM SDK

Accéder au jeton d'enregistrement FCM

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 reçoit le jeton avec le rappel OnTokenReceived, qui doit être défini dans la classe qui implémente firebase::messaging::Listener.

Si vous souhaitez cibler cette instance d'application spécifique, vous devez avoir accès à ce jeton.

Remarque concernant la distribution des messages sur Android

Lorsque l'application n'est pas du tout en cours d'exécution et qu'un utilisateur appuie sur une notification, le message n'est pas, par défaut, acheminé via les rappels intégrés de FCM's. 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 l'Intent au 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);
  }
}

Les messages reçus lorsque l'application est en arrière-plan utilisent le contenu de leur champ de notification pour remplir la notification de la barre d'état système, mais ce contenu de notification n'est pas communiqué à FCM. Autrement dit, Message::notification sera nul.

En résumé :

Gestion personnalisée des messages sur Android

Par défaut, les notifications envoyées à l'application sont transmises à ::firebase::messaging::Listener::OnMessageReceived, mais dans certains cas, vous pouvez remplacer 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 fichier AndroidManifest.xml de votre projet.

Remplacer les méthodes ListenerService

ListenerService est la classe Java qui intercepte les messages entrants envoyés à l'application et les achemine 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 contenant uniquement des données), 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 FCM's par défaut ListenerService :

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 comporte également quelques autres méthodes moins fréquemment utilisées. Elles peuvent également être remplacées. Pour en savoir plus, consultez la référence 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 prendre effet. 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 au ListenerService de s'exécuter. Ce ListenerService doit être remplacé par le service d'écoute personnalisé. Pour ce faire, supprimez le ListenerService par défaut et ajoutez le service personnalisé, ce qui peut être effectué avec les lignes suivantes dans le fichier AndroidManifest.xml de vos projets :

<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++ (7.1.0 et versions ultérieures) 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 des instances d'application. 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 un consentement explicite avant d'utiliser le jeton, vous pouvez empêcher sa 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 :

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

FirebaseMessagingAutoInitEnabled = NO

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

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

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

Messages avec liens profonds sur Android

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 filtre d'intent à l'activité qui gère les liens profonds pour votre application. Le filtre d'intent doit intercepter 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>

Il est également possible de 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 démarre l'activité avec ce filtre d'intent pour gérer le lien.

Étapes suivantes

Une fois les étapes de configuration terminées, voici quelques options pour continuer à utiliser FCM pour C++ :

• Envoyer des messages aux appareils
• Recevoir des messages dans une application C++
• Envoyer des messages à des sujets