Configurer une application cliente Firebase Cloud Messaging avec C++

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

Configurer Firebase et le SDK FCM

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 aurez besoin d'accéder à ce jeton.

Remarque sur la livraison des messages sur Android

Lorsque l'application ne fonctionne pas du tout 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. Dans ce cas, les charges utiles de message sont reçues via une Intent utilisée 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 Activity et transmettre l' 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);
  }
}

Les messages reçus lorsque l'application est en arrière-plan ont le contenu de leur champ de notification utilisé pour remplir la notification de la barre d'état système, mais ce contenu de notification ne sera pas communiqué à FCM. C'est-à-dire que 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 souhaiterez peut-être remplacer le comportement par défaut. Pour ce faire sur Android, vous devrez écrire des classes personnalisées qui étendent com.google.firebase.messaging.cpp.ListenerService ainsi que mettre à jour le AndroidManifest.xml de votre projet.

Remplacer les méthodes ListenerService .

Le 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 lorsque l'application est en arrière-plan et qu'elle reçoit une charge utile de données uniquement), les messages passeront par l'un des rappels fournis sur cette classe. Pour ajouter un comportement personnalisé à la gestion des messages, vous devrez é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 basées sur 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 a également quelques autres méthodes qui sont utilisées moins fréquemment. Celles-ci peuvent également être remplacées. Pour plus d'informations, 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 AndroidManifest.xml pour prendre effet. Assurez-vous que le manifeste inclut les outils de fusion en déclarant l'attribut approprié dans la <manifest> , comme ceci :

<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 y a un fichier AndroidManifest.xml qui déclare le ListenerService par défaut de FCM. Ce manifeste est normalement fusionné avec le manifeste spécifique au projet, qui permet à ListenerService de s'exécuter. Ce service d' ListenerService doit être remplacé par le service d'écoute personnalisé. Cela est accompli en supprimant le ListenerService par défaut et en ajoutant le service personnalisé, ce qui peut être fait avec les lignes suivantes de votre fichier de projets AndroidManifest.xml :

<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 de Firebase C++ SDK (à partir de la version 7.1.0) utilisent JobIntentService 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 télécharge l'identifiant et les données de configuration sur Firebase. Si vous souhaitez obtenir un opt-in explicite avant d'utiliser le jeton, vous pouvez empêcher la génération au moment de la configuration en désactivant FCM (et sur Android, Analytics). 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);

Cette valeur persiste lors des redémarrages de l'application une fois définie.

Gestion des messages avec des liens profonds sur Android

FCM permet d'envoyer des messages contenant un lien profond vers votre application. Pour recevoir des messages contenant un lien profond, vous devez ajouter un nouveau filtre d'intention à l'activité qui gère les liens profonds pour votre application. Le filtre d'intention doit capturer 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'intention plus flexible. Par 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'intention pour gérer le lien.

Prochaines étapes

Après avoir configuré l'application cliente, vous êtes prêt à envoyer des messages en aval et de sujet avec Firebase. Pour en savoir plus, consultez cette fonctionnalité présentée dans l' exemple de démarrage rapide que vous pouvez télécharger, exécuter et examiner.

Pour ajouter d'autres comportements plus avancés à votre application, consultez les guides d'envoi de messages depuis un serveur d'application :

• Envoyer des messages de sujet
• Envoyer aux groupes d'appareils

Gardez à l'esprit que vous aurez besoin d'une implémentation de serveur pour utiliser ces fonctionnalités.