Configurer une application cliente Firebase Cloud Messaging avec C++

Pour écrire votre multiplateformes Firebase cloud messagerie application client avec C ++, utilisez le Firebase Cloud Messaging API. Le SDK C++ fonctionne à la fois pour Android et iOS, avec une configuration supplémentaire requise pour chaque plate-forme.

Configurer Firebase et le SDK FCM

Android

  1. Si vous avez pas déjà, ajoutez Firebase à votre projet C ++ .

    • Dans les instructions de configuration liées, passez en revue les exigences relatives à l'appareil et à l'application pour l'utilisation du SDK Firebase C++, y compris la recommandation d'utiliser CMake pour créer votre application.

    • Dans votre niveau de projet build.gradle fichier, assurez - vous d'inclure le référentiel Maven de Google à la fois votre buildscript et allprojects sections.

  2. Créer un objet App Firebase, en passant dans l'environnement JNI et activité:

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

  3. Définir une classe qui implémente le firebase::messaging::Listener interface.

  4. Initialize FCM, en passant dans l'App et un Listener construit:

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

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

iOS

  1. Vous avez besoin d' un valide APNs certificat. Si vous ne possédez pas déjà un, assurez - vous de créer un dans le Apple Developer Member Center .
  2. Si vous avez pas déjà, ajoutez Firebase à votre projet C ++ . Ensuite, pour configurer votre projet pour FCM :
    1. Dans PODFILE de votre projet, ajoutez la dépendance de la FCM:
      pod 'Firebase/Messaging'
    2. Faites glisser le firebase.framework et firebase_messaging.framework cadres dans votre projet Xcode du Firebase C ++ SDK .
  3. Configurez votre projet Xcode pour activer les notifications push :

    1. Sélectionnez le projet de la zone Navigator.
    2. Sélectionnez la cible du projet de la zone éditeur.
    3. Sélectionnez l'onglet Général de la zone éditeur.

      1. Faites défiler vers le bas pour les cadres et les bibliothèques associées, puis cliquez sur le bouton + pour ajouter des cadres.
      2. Dans la fenêtre qui apparaît, faites défiler jusqu'à UserNotifications.framework, cliquez sur cette entrée, puis cliquez sur Ajouter.

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

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

      1. Mettez les notifications Push sur On.
      2. Faites défiler jusqu'à Modes de fond, puis activez-la.
      3. Sélectionnez les notifications à distance sous les modes d'arrière - plan.
  4. Créer un objet App Firebase:

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

  5. Définir une classe qui implémente le firebase::messaging::Listener interface.

  6. Initialize Firebase Nuage de messagerie, en passant dans l'App et construit Listener:

    ::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 d'application cliente. L'application recevra le jeton avec le OnTokenReceived rappel, qui devrait ê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 s'exécute 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 messages sont reçus par une Intent utilisée pour démarrer l'application. Pour avoir FCM transférer ces messages entrants vers le C ++ rappel bibliothèque, vous devez remplacer la méthode onNewIntent dans votre activité et passer l' Intent du 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 alors que 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é au FCM. C'est un Message::notification sera un nul.

En résumé:

État de l'application Notification Données Les deux
Premier plan OnMessageReceived OnMessageReceived OnMessageReceived
Fond Barre d'état système OnMessageReceived Notification : barre d'état système
Données : en extras de l'intention.

Gestion des messages personnalisés 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 devrez écrire des classes personnalisées qui étendent com.google.firebase.messaging.cpp.ListenerService ainsi que la mise à jour de votre projet AndroidManifest.xml .

Remplacer ListenerService Méthodes.

Le ListenerService est la classe Java qui intercepte les messages entrants envoyés à l'application et les achemine à 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 devez étendre par défaut de la FCM ListenerService :

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

class MyListenerService extends ListenerService {

En redéfinissant la méthode ListenerService.onMessageReceived , vous pouvez effectuer des actions basées sur le reçu RemoteMessage objet et obtenir les données de message:

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

ListenerService a aussi quelques autres méthodes qui sont moins fréquemment utilisés. Ceux - ci peuvent être outrepassées ainsi, pour plus d' informations voir le FirebaseMessagingService référence.

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

Mise à jour AndroidManifest.xml

Une fois que vos classes personnalisées ont été écrits, ils doivent être inclus dans le AndroidManifest.xml pour prendre effet. Assurez -vous que le manifeste comprend les outils de fusion en déclarant l'attribut approprié à l' intérieur du <manifest> balise, 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 le firebase_messaging_cpp.aar archives il y a un AndroidManifest.xml fichier qui déclare par défaut de la FCM ListenerService . Ce manifeste est normalement fusionné avec le manifeste spécifique du projet qui est de savoir comment l' ListenerService est en mesure d'exécuter. Cette ListenerService doit remplacer par le service d'écoute de cusom. Cela est accompli en supprimant la valeur par défaut ListenerService et en ajoutant le service personnalisé, ce qui peut être fait avec les lignes suivantes vos projets AndroidManifest.xml fichier:

<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 (7.1.0 et suivantes) l' utilisation JobIntentService qui nécessite des modifications supplémentaires dans AndroidManifest.xml fichier.

<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 appareils. 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 une acceptation 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 (pas votre GoogleService-Info.plist ) sur iOS 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>

iOS

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.

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

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 par sujet avec Firebase. Pour en savoir plus, voir cette fonctionnalité démontrée dans l' échantillon de QuickStart que vous pouvez télécharger, exécuter et examen.

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

Gardez à l' esprit que vous aurez besoin d' une mise en œuvre du serveur pour faire usage de ces caractéristiques.