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 :

  1. Votre numéro d'identification de l'application Vonage
  2. 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).
  3. Votre ID de projet Firebase
  4. 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.

Displaying the project settings location
Displaying the project ID location

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.

Displaying the project settings location
Displaying the server key location

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

Android Push Certificate Uploading Tool success

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

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 :

VONAGE_APP_ID= VONAGE_JWT= FIREBASE_PROJECT_ID= FIREBASE_SERVER_KEY= curl -v -X PUT \ -H "Authorization: Bearer $VONAGE_JWT" \ -H "Content-Type: application/json" \ -d "{\"token\":\"$FIREBASE_SERVER_KEY\", \"projectId\":\"$FIREBASE_PROJECT_ID\"}" \ https://api.nexmo.com/v1/applications/$VONAGE_APP_ID/push_tokens/android

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

Add App getting started screen with options for ios, android, web, unity and flutter

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

Form to register your application with your Firebase project, package name is required.

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.

Android studio with project view selected and the google-service.json added in the app module directory

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()
    }
}

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')
}

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")
}

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) {}
        })
    }
}

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 :

Arrow showing the location of the manifest file
<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")
                }
            })
        }
    }
}

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)

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.