Pour écrire votre application client Firebase Cloud Messaging multiplateforme 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
Android
Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet C++ .
Dans les instructions de configuration liées, passez en revue les exigences relatives à l'appareil et à l'application pour utiliser le SDK Firebase C++, y compris la recommandation d'utiliser CMake pour créer votre application.
Dans votre fichier
build.gradle
au niveau du projet, assurez-vous d'inclure le référentiel Maven de Google dans les sectionsbuildscript
etallprojects
.
Créez un objet Firebase App, en passant l'environnement JNI et l'activité :
app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);
Définissez une classe qui implémente l'interface
firebase::messaging::Listener
.Initialisez FCM en passant l'application et un auditeur construit :
::firebase::messaging::Initialize(app, listener);
Les applications qui s'appuient sur le SDK des services Google Play doivent rechercher sur l'appareil un APK de services Google Play compatible avant d'accéder aux fonctionnalités. Pour en savoir plus, reportez-vous à Rechercher l'APK des services Google Play .
iOS+
- Vous avez besoin d'un certificat APNs valide. Si vous n'en avez pas déjà un, assurez-vous d'en créer un dans le Centre des membres des développeurs Apple .
- Si vous ne l'avez pas déjà fait, ajoutez Firebase à votre projet C++ . Ensuite, pour configurer votre projet pour FCM :
- Dans le Podfile de votre projet, ajoutez la dépendance FCM :
pod 'FirebaseMessaging'
- Faites glisser les frameworks
firebase.framework
etfirebase_messaging.framework
dans votre projet Xcode à partir du SDK Firebase C++ .
- Dans le Podfile de votre projet, ajoutez la dépendance FCM :
Configurez votre projet Xcode pour activer les notifications push :
- Sélectionnez le projet dans la zone Navigateur .
- Sélectionnez la cible du projet dans la zone Éditeur .
Sélectionnez l'onglet Général dans la zone Éditeur .
- Faites défiler jusqu'à Linked Frameworks and Libraries , puis cliquez sur le bouton + pour ajouter des frameworks.
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.
Sélectionnez l'onglet Capacités dans la zone Éditeur .
- Activez les notifications push .
- Faites défiler jusqu'à Modes d'arrière-plan , puis réglez-le sur Activé .
- Sélectionnez Notifications à distance sous Modes d'arrière-plan .
Créez un objet Firebase App :
app = ::firebase::App::Create(::firebase::AppOptions());
Définissez une classe qui implémente l'interface
firebase::messaging::Listener
.Initialisez Firebase Cloud Messaging, en transmettant l'application et un écouteur construit :
::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 client. 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 devrez accéder à ce jeton.
Remarque concernant 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 des messages sont reçues via un Intent
utilisé pour démarrer l'application. Pour que FCM transmette ces messages entrants au rappel de la bibliothèque C++, vous devez remplacer la méthode onNewIntent
dans votre Activity 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 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. Autrement dit, Message::notification
sera nul.
En résumé:
État de l'application | Notification | Données | Les deux |
---|---|---|---|
Premier plan | OnMessageReceived | OnMessageReceived | OnMessageReceived |
Arrière-plan | Barre d'état système | OnMessageReceived | Notification : barre d'état système Données : en extras de l'intention. |
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 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 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 contenant uniquement des données), les messages passeront par l'un des rappels fournis sur cette classe. Pour ajouter un comportement personnalisé à la gestion des messages, vous devrez étendre 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
propose également quelques autres méthodes moins fréquemment utilisées. Ceux-ci peuvent également être remplacés. 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 balise <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 existe un fichier AndroidManifest.xml
qui déclare ListenerService
par défaut de FCM. Ce manifeste est normalement fusionné avec le 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é. 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 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 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 un consentement 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 plateformes 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>
Rapide
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 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 client, vous êtes prêt à envoyer des messages en aval et thématiques avec Firebase. Pour en savoir plus, consultez cette fonctionnalité illustrée 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 :
Gardez à l’esprit que vous aurez besoin d’une implémentation de serveur pour utiliser ces fonctionnalités.