Vue d'ensemble
Lors d'événements entrants tels qu'un nouveau message ou un appel entrant, l'utilisateur s'attend souvent à recevoir une notification push. Si l'application n'est pas active (elle est en arrière-plan), les notifications push sont le seul moyen d'informer l'application des nouveaux événements.
Ce guide explique comment configurer votre application Android pour recevoir des notifications push du Client SDK.
Connecter Vonage à Firebase
Pour recevoir des notifications push, vous devez connecter Vonage à Firebase. Pour ce faire, vous aurez besoin des éléments suivants :
- Votre numéro d'identification de l'application Vonage
- La clé privée de votre application Vonage (méthode de l'outil de téléchargement) ou un JWT de l'administrateur Vonage (méthode du terminal).
- Votre ID de projet Firebase
- Votre clé de serveur Firebase
Obtenir un numéro d'identification de l'application Vonage
Obtenez votre identifiant d'application API Vonage. Vous pouvez accéder aux applications existantes dans la section tableau de bord. Si vous n'avez pas encore d'application, vous pouvez en créer une nouvelle via CLI Vonage.
Obtenir un ID de projet Firebase
Obtenez l'identifiant de votre projet Firebase à partir de la page Console Firebase. Naviguez jusqu'à Firebase console -> Project settings -> General.


Obtenir une clé de serveur Firebase
Obtenez votre clé de serveur Firebase à partir de la page Console Firebase. Naviguez jusqu'à Firebase console -> Project settings -> Service accounts et générer une nouvelle clé privée.


Connectez votre application Vonage à Firebase
Vous connectez Vonage à votre application Firebase en effectuant une requête POST. Vous pouvez faire cette demande en utilisant l'outil de téléchargement ou en faisant une demande POST directement.
Utilisation de l'outil de téléchargement
L'outil Android Push Certificate Uploading Tool, disponible sur GitHubIl vous permet de télécharger des données à l'aide d'une interface utilisateur.
Pour utiliser l'outil, vous devez l'exécuter localement ou le déployer. Vous pouvez suivre les instructions dans la page d'accueil du projet GitHub. LISEZ-MOI.
Une fois l'outil lancé, entrez votre ID d'application Vonage, votre fichier de clé privée, votre ID de projet Firebase et votre clé de serveur Firebase, puis cliquez sur télécharger. L'état de votre téléchargement s'affichera sur la page une fois qu'il sera terminé :

Utilisation du terminal
Pour connecter le service de push du backend de Vonage avec l'application Firebase, vous devez faire une simple requête POST. Avant de faire la requête, vous devrez générer le JWT du développeur Vonage (l'outil de téléchargement ci-dessus génère ce JWT sous le capot).
NOTE JWTs sont utilisés pour authentifier un utilisateur dans le Client SDK.
Pour générer un JWT d'administration Vonage, exécutez la commande suivante. N'oubliez pas de remplacer l'élément VONAGE_APP_ID avec l'ID de votre application Vonage :
# A command with parameters
vonage jwt create `
--app-id='00000000-0000-0000-0000-000000000000' `
--private-key=./private.key
# Will produce a token
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MzYyODE5NDYsImp0aSI6IjBmZjcwZDNmLTAzN2EtNGY4MC04ODZjLWI3MmM3MmQyMWNmMiIsImlhdCI6MTczNjI4MTA0NiwiYXBwbGljYXRpb25faWQiOiIwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDAifQ.gA7jClpqaZ2OoS0iri-zGCbda4jO7C0M8mka0EnSyjlds1EeY8fNoBEx3FTXHfkkzzrj0TskrWc_dcs1wuM8Kx55c5rLQ7taVpDAYopKSc_CeeOaad8S6aWnRkTUTNeduO4aIn-0CbyRTluBYsH1RBqYBQvobuQIDEwbFw8xBgx0UfREMMN6DAWknR57eiVXN9x_oD6CGQJ1yV3025nGboeMsP9YgX4Nwc-rE2r8c1ZGwCLO81x8i19Qil3Nwu5q1nzouyavQjIw00B_TZkushnI1ufdi_GNqk-h5q2HvGkg7Pj9bVkZHFdVTO8im03JYNyJmcV83vnpjOLuCFRzxQ
REM A command with parameters
vonage jwt create ^
--app-id='00000000-0000-0000-0000-000000000000' ^
--private-key=./private.key
REM Will produce a token
eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MzYyODE5NDYsImp0aSI6IjBmZjcwZDNmLTAzN2EtNGY4MC04ODZjLWI3MmM3MmQyMWNmMiIsImlhdCI6MTczNjI4MTA0NiwiYXBwbGljYXRpb25faWQiOiIwMDAwMDAwMC0wMDAwLTAwMDAtMDAwMC0wMDAwMDAwMDAwMDAifQ.gA7jClpqaZ2OoS0iri-zGCbda4jO7C0M8mka0EnSyjlds1EeY8fNoBEx3FTXHfkkzzrj0TskrWc_dcs1wuM8Kx55c5rLQ7taVpDAYopKSc_CeeOaad8S6aWnRkTUTNeduO4aIn-0CbyRTluBYsH1RBqYBQvobuQIDEwbFw8xBgx0UfREMMN6DAWknR57eiVXN9x_oD6CGQJ1yV3025nGboeMsP9YgX4Nwc-rE2r8c1ZGwCLO81x8i19Qil3Nwu5q1nzouyavQjIw00B_TZkushnI1ufdi_GNqk-h5q2HvGkg7Pj9bVkZHFdVTO8im03JYNyJmcV83vnpjOLuCFRzxQ
NOTE Un JWT d'administration est un JWT sans sous-revendication. Pour plus de détails sur la manière de générer un JWT, voir le document guide d'installation.
Remplir VONAGE_APP_ID, VONAGE_JWT, FIREBASE_PROJECT_ID et FIREBASE_SERVER_KEY avec les valeurs obtenues précédemment et exécutez la commande ci-dessous pour envoyer la requête :
NOTE Il n'y a pas de validation à ce stade. Les 200 signifie que Vonage a reçu les données et les a stockées, mais n'a pas vérifié que les valeurs étaient valides.
Si toutes les valeurs sont correctes, vous devriez voir 200 dans le terminal.
Configurer le projet Firebase pour votre application Android
Afin d'activer les notifications push pour votre application Android, vous devez configurer votre application Android.
Configurer votre projet Android
Commençons par configurer votre projet Android avec les dépendances nécessaires.
Ajouter la dépendance Client SDK
Ajouter le Client SDK à votre projet.
Ajouter la configuration Firebase à votre application
Avant de mettre en place la configuration spécifique aux notifications push, il y a quelques étapes générales à suivre pour mettre en place Firebase dans votre application.
NOTE que vous pouvez sauter cette étape si votre application utilise déjà d'autres produits Firebase.
Depuis votre projet Firebase, cliquez sur l'option "add Android app" :

Remplissez le formulaire affiché pour enregistrer votre application dans le projet Firebase.

Un bouton "Télécharger google-services.json" apparaît alors, cliquez dessus et téléchargez le fichier.
Passez maintenant à la vue Projet dans Android Studio pour voir le répertoire racine de votre projet.
Déplacez le fichier google-services.json que vous avez téléchargé dans le répertoire racine du module de votre application Android.

Enfin, vous devez ajouter le plugin Google services, qui chargera le fichier google-services.json. Modifiez votre projet build.gradle pour l'inclure :
buildscript {
repositories {
// Check that you have the following line (if not, add it):
google()
}
dependencies {
// Add this line
classpath("com.google.gms:google-services:4.3.10")
}
}
allprojects {
repositories {
// Check that you have the following line (if not, add it):
google()
}
}
buildscript {
repositories {
// Check that you have the following line (if not, add it):
google() // Google's Maven repository
}
dependencies {
// Add this line
classpath 'com.google.gms:google-services:4.3.10'
}
}
allprojects {
repositories {
// Check that you have the following line (if not, add it):
google() // Google's Maven repository
}
}
Et dans votre niveau d'application build.gradle implémenter la base Firebase BoM
plugins {
id("com.android.application")
id("com.google.gms.google-services")
}
dependencies {
// Import the Firebase BoM
implementation platform('com.google.firebase:firebase-bom:30.1.0')
}
apply plugin: 'com.android.application'
// Add this line
apply plugin: 'com.google.gms.google-services'
dependencies {
// Import the Firebase BoM
implementation platform('com.google.firebase:firebase-bom:30.1.0')
}
Ajouter la dépendance Firebase Cloud Messaging
Dans votre IDE, au niveau de votre application build.gradle (généralement app/build.gradle), ajouter le firebase-messaging dépendance :
dependencies{
implementation("com.google.firebase:firebase-messaging:21.0.1")
}
dependencies{
implementation 'com.google.firebase:firebase-messaging:21.0.1'
}
NOTE : Le numéro de la version la plus récente est indiqué sur le site web de la Commission européenne. Site web de Firebase.
Implémenter une classe de service personnalisée pour recevoir des notifications push
Si vous n'en avez pas encore, créez une classe (service) qui étend le concept de FirebaseMessagingService.
Pour que Vonage puisse envoyer des notifications push à un appareil, le serveur Vonage doit connaître l'adresse de l'appareil. InstanceID.
Dans votre classe qui étend FirebaseMessagingService, surcharge onNewToken() et mettre à jour la méthode NexmoClient en passant un nouveau token:
class MyFirebaseMessagingService: FirebaseMessagingService() {
// We can retrieve client instance only if it has been already initialized
// NexmoClient.Builder().build(context)
private val client = NexmoClient.get()
override fun onNewToken(token: String) {
super.onNewToken(token)
client.enablePushNotifications(token, object: NexmoRequestListener<Void> {
override fun onSuccess(p0: Void?) { }
override fun onError(apiError: NexmoApiError) {}
})
}
}
public class MyFirebaseMessagingService extends FirebaseMessagingService {
// We can retrieve client instance only if it has been already initialized
// new NexmoClient.Builder().build(context)
private NexmoClient client = NexmoClient.get();
@Override
public void onNewToken(@NonNull String token) {
super.onNewToken(token);
client.enablePushNotifications(token, new NexmoRequestListener<Void>() {
@Override
public void onSuccess(@Nullable Void p0) {}
@Override
public void onError(@NonNull NexmoApiError nexmoApiError) {}
});
}
}
Assurez-vous que votre service est déclaré dans votre AndroidManifest.xml (typiquement app/src/main/AndroidManifest.xml) en ajoutant service étiquette à l'intérieur application étiquette :

<service android:name=".MyFirebaseMessagingService"
android:exported="false">
<intent-filter>
<action android:name="com.google.firebase.MESSAGING_EVENT" />
</intent-filter>
</service>
Recevoir des notifications push
Les notifications push sont reçues dans votre implémentation de MyFirebaseMessagingService, le onMessageReceived() méthode. Vous pouvez utiliser la méthode NexmoClient.isNexmoPushNotification(message.data)) pour déterminer si le message est envoyé par le serveur Vonage.
Utilisation processPushNotification(message.data, listener) pour traiter les données reçues de Firebase Cloud Messaging (FCM) dans un objet prêt à l'emploi :
class MyFirebaseMessagingService : FirebaseMessagingService() {
// We can retrieve client instance only if it has been already initialized
// in Application class or Activity:
// NexmoClient.Builder().build(context)
private val client = NexmoClient.get()
override fun onNewToken(token: String) {
super.onNewToken(token)
//...
}
override fun onMessageReceived(remoteMessage: RemoteMessage) {
// determine if the message is sent from Nexmo server
if (NexmoClient.isNexmoPushNotification(remoteMessage.data)) {
client.processNexmoPush(remoteMessage.data, object : NexmoPushEventListener {
override fun onIncomingCall(call: NexmoCall?) {
Log.d("TAG", "FirebaseMessage:onIncomingCall() with: $call")
}
override fun onNewEvent(event: NexmoEvent?) {
Log.d("TAG", "FirebaseMessage:onNewEvent() with: $event")
}
override fun onError(apiError: NexmoApiError?) {
Log.d("TAG", "FirebaseMessage:onError() with: $apiError")
}
})
}
}
}
public class MyFirebaseMessagingService extends FirebaseMessagingService {
// We can retrieve client instance only if it has been already initialized
// in Application class or Activity:
// new NexmoClient.Builder().build(context)
private NexmoClient client = NexmoClient.get();
@Override
public void onNewToken(@NonNull String token) {
super.onNewToken(token);
//...
}
@Override
public void onMessageReceived(@NonNull RemoteMessage remoteMessage) {
super.onMessageReceived(remoteMessage);
// determine if the message is sent from Nexmo server
if (NexmoClient.isNexmoPushNotification(remoteMessage.getData())) {
client.processNexmoPush(remoteMessage.getData(), new NexmoPushEventListener() {
@Override
public void onIncomingCall(NexmoCall call) {
Log.d("TAG", "FirebaseMessage:onIncomingCall() with: " + call);
}
@Override
public void onNewEvent(NexmoEvent event) {
Log.d("TAG", "FirebaseMessage:onNewEvent() with: " + event);
}
@Override
public void onError(NexmoApiError apiError) {
Log.d("TAG", "FirebaseMessage:onError() with: " + apiError);
}
});
}
}
}
NOTE : Afin de traiter la notification push et d'appliquer toute méthode sur le fichier NexmoCall (par exemple, répondre, raccrocher, etc.), l'objet NexmoClient doit être initialisé et l'utilisateur doit être connecté.
Configurer le TTL des notifications push
Vous pouvez configurer le temps de vie (TTL) pour les notifications push, ce qui empêchera les notifications push périmées d'être délivrées à un appareil après qu'elles ne sont plus pertinentes. La valeur par défaut est de 120 secondes. Pour définir le TTL, configurez le paramètre NexmoClient:
// TTL value is in seconds, TTL ranges from 0 to 300.
val nexmoClient = NexmoClient.Builder()
.pushNotificationTTL(30)
.build(context)
// TTL value is in seconds, TTL ranges from 0 to 300.
NexmoClient nexmoClient = new NexmoClient.Builder()
.pushNotificationTTL(30)
.build(this);
Changements apportés à la NexmoClient doit être effectuée avant le premier appel à NexmoClient().get().
La mise en place de l'ensemble
Vous pouvez maintenant tester votre configuration de notification push en appelant l'utilisateur de votre application. L'appel entrant déclenchera onIncomingCall comme indiqué ci-dessus. Si vous avez enregistré un récepteur d'appels entrants avec la fonction NexmoClient.addIncomingCallListener ailleurs dans votre application Android, cet écouteur aura la priorité sur l'écouteur onIncomingCallsur le NexmoPushEventListener.
Conclusion
Dans ce guide, vous avez vu comment mettre en place les notifications push. Vous trouverez également un exemple de projet qui utilise la fonction Service de connexion et les notifications push pour gérer un appel entrant à l'aide de l'interface utilisateur du système Android sur GitHub.