Übersicht
Bei eingehenden Ereignissen wie einer neuen Nachricht oder einem eingehenden Anruf erwartet der Nutzer oft eine Push-Benachrichtigung. Wenn die App nicht aktiv ist (sie befindet sich im Hintergrund), sind Push-Benachrichtigungen die einzige Möglichkeit, die App über neue Ereignisse zu informieren.
Diese Anleitung erklärt, wie Sie Ihre Android-App für den Empfang von Push-Benachrichtigungen vom Client SDK konfigurieren.
Vonage mit Firebase verbinden
Um Push-Benachrichtigungen zu erhalten, müssen Sie Vonage mit Firebase verbinden. Hierfür benötigen Sie Folgendes:
- Ihre Vonage Application ID
- Der private Schlüssel Ihrer Vonage Application (Upload-Tool-Methode) oder ein Vonage Admin-JWT (Terminal-Methode)
- Ihre Firebase-Projekt-ID
- Ihr Firebase-Server-Schlüssel
Abrufen einer Vonage Anwendungs-ID
Beziehen Sie Ihre Vonage API Application id. Sie können auf die vorhandenen Applications in der Dashboard. Wenn Sie noch keine Anwendung haben, können Sie eine neue Anwendung erstellen über Vonage CLI.
Eine Firebase-Projekt-ID erhalten
Holen Sie sich Ihre Firebase-Projekt-ID aus der Firebase-Konsole. Navigieren Sie zu Firebase console -> Project settings -> General.


Firebase-Server-Schlüssel anfordern
Holen Sie sich Ihren Firebase Server Key von der Firebase-Konsole. Navigieren Sie zu Firebase console -> Project settings -> Service accounts und erzeugen einen neuen privaten Schlüssel.


Verbinden Sie Ihre Vonage-Applikation mit Firebase
Sie verbinden Vonage mit Ihrer Firebase-Anwendung, indem Sie eine POST-Anfrage stellen. Sie können diese Anfrage mit dem Upload-Tool oder direkt mit einer POST-Anfrage stellen.
Verwendung des Upload-Tools
Das Android Push Certificate Uploading Tool, verfügbar auf GitHubermöglicht Ihnen das Hochladen mit einer Benutzeroberfläche.
Um das Tool zu verwenden, müssen Sie es lokal ausführen oder bereitstellen. Sie können den Anweisungen in der GitHub-Projektseite folgen README.
Sobald das Tool läuft, geben Sie Ihre Vonage Application ID, die private Schlüsseldatei, die Firebase Projekt ID und den Firebase Server Key ein und klicken Sie auf Upload. Der Status Ihres Uploads wird auf der Seite angezeigt, sobald er abgeschlossen ist:

Verwendung des Terminals
Um den Vonage Backend-Push-Service mit der Firebase-Anwendung zu verbinden, müssen Sie eine einzelne POST-Anfrage stellen. Vor der Anfrage müssen Sie die JWT des Vonage-Entwicklers generieren (das oben genannte Upload-Tool generiert diese JWT unter der Haube).
ANMERKUNG JWTs werden verwendet, um einen Benutzer beim Client SDK zu authentifizieren.
Führen Sie den folgenden Befehl aus, um ein Vonage admin JWT zu erzeugen. Denken Sie daran, die VONAGE_APP_ID mit der ID Ihrer Vonage-Anwendung:
# 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
ANMERKUNG Ein Admin-JWT ist ein JWT ohne Sub-Claim. Weitere Einzelheiten zur Erzeugung eines JWT finden Sie in der Setup-Anleitung.
Füllen Sie VONAGE_APP_ID, VONAGE_JWT, FIREBASE_PROJECT_ID und FIREBASE_SERVER_KEY mit den zuvor erhaltenen Werten und führen Sie den folgenden Befehl aus, um die Anfrage zu senden:
ANMERKUNG An diesem Endpunkt findet keine Validierung statt. Die 200 Rückgabecode bedeutet, dass Vonage die Daten erhalten und gespeichert hat, aber nicht überprüft hat, ob die Werte gültig sind.
Wenn alle Werte korrekt sind, sollten Sie Folgendes sehen 200 Antwortcode auf dem Terminal.
Firebase-Projekt für Ihre Android-Anwendung einrichten
Um Push-Benachrichtigungen für Ihre Android-Anwendung zu aktivieren, müssen Sie Ihre Android-Anwendung konfigurieren.
Konfigurieren Sie Ihr Android-Projekt
Beginnen wir damit, Ihr Android-Projekt mit den erforderlichen Abhängigkeiten zu konfigurieren.
Hinzufügen der Client SDK-Abhängigkeit
Hinzufügen des Client SDK für Ihr Projekt.
Firebase-Konfiguration zu Ihrer App hinzufügen
Bevor wir die Push-Benachrichtigungs-spezifische Konfiguration einrichten, müssen Sie einige allgemeine Schritte unternehmen, um Firebase in Ihrer Anwendung einzurichten.
ANMERKUNG dass Sie diesen Schritt überspringen können, wenn Ihre Anwendung bereits andere Firebase-Produkte verwendet.
Klicken Sie in Ihrem Firebase-Projekt auf die Option "Android-App hinzufügen":

Füllen Sie das angezeigte Formular aus, um Ihre Anwendung im Firebase-Projekt zu registrieren

Sie erhalten dann eine Schaltfläche "Download google-services.json", klicken Sie darauf und laden Sie die Datei herunter.
Wechseln Sie nun zur Projektansicht in Android Studio, um Ihr Projektstammverzeichnis zu sehen.
Verschieben Sie die heruntergeladene Datei google-services.json in das Stammverzeichnis Ihres Android-App-Moduls.

Schließlich müssen Sie das Google Services-Plugin hinzufügen, das die Datei google-services.json lädt. Ändern Sie Ihre Projektebene build.gradle Datei, um dies aufzunehmen:
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
}
}
Und in Ihrer App-Ebene build.gradle die Firebase BoM-Basis implementieren
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')
}
Firebase Cloud Messaging-Abhängigkeit hinzufügen
In Ihrer IDE, auf der Ebene Ihrer Anwendung build.gradle Datei (normalerweise app/build.gradle), fügen Sie die firebase-messaging Abhängigkeit:
dependencies{
implementation("com.google.firebase:firebase-messaging:21.0.1")
}
dependencies{
implementation 'com.google.firebase:firebase-messaging:21.0.1'
}
HINWEIS: Die aktuelle Versionsnummer finden Sie in der Firebase-Website.
Implementierung einer benutzerdefinierten Dienstklasse zum Empfang von Push-Benachrichtigungen
Wenn Sie noch keine Klasse haben, erstellen Sie eine Klasse (Dienst), die die FirebaseMessagingService.
Damit Vonage Push-Benachrichtigungen an ein Gerät senden kann, muss der Vonage-Server die Daten des Geräts kennen. InstanceID.
In Ihrer Klasse, die die FirebaseMessagingServiceüberschreiben onNewToken() Methode und aktualisieren Sie die NexmoClient durch Übergabe einer neuen 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) {}
});
}
}
Stellen Sie sicher, dass Ihr Dienst in Ihrem AndroidManifest.xml (typischerweise app/src/main/AndroidManifest.xml) durch Hinzufügen von service Tag innen application Tag:

<service android:name=".MyFirebaseMessagingService"
android:exported="false">
<intent-filter>
<action android:name="com.google.firebase.MESSAGING_EVENT" />
</intent-filter>
</service>
Empfang von Push-Benachrichtigungen
Push-Benachrichtigungen werden in Ihrer Implementierung von MyFirebaseMessagingServicean. onMessageReceived() Methode. Sie können verwenden NexmoClient.isNexmoPushNotification(message.data)) um festzustellen, ob die Nachricht vom Vonage-Server gesendet wird.
Verwenden Sie processPushNotification(message.data, listener) um die von Firebase Cloud Messaging (FCM) empfangenen Daten in ein gebrauchsfertiges Objekt zu verarbeiten:
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);
}
});
}
}
}
HINWEIS: Um die Push-Benachrichtigung zu verarbeiten und alle Methoden auf die NexmoCall Objekt (z. B. Antwort, Auflegen usw.), die NexmoClient muss initialisiert werden und der Benutzer muss eingeloggt.
TTL für Push-Benachrichtigung konfigurieren
Sie können die Time-to-Live (TTL) für Push-Benachrichtigungen konfigurieren. Dadurch wird verhindert, dass veraltete Push-Benachrichtigungen an ein Gerät gesendet werden, wenn sie nicht mehr relevant sind. Der Standardwert ist 120 Sekunden. Um die TTL einzustellen, konfigurieren Sie die 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);
Änderungen der NexmoClient Konfiguration muss vor dem ersten Aufruf von NexmoClient().get().
Alles zusammenfügen
Jetzt können Sie Ihre Push-Benachrichtigung testen, indem Sie den Benutzer Ihrer Anwendung anrufen. Der eingehende Anruf löst onIncomingCall Callback wie oben gezeigt. Wenn Sie einen Hörer für eingehende Anrufe registriert haben mit NexmoClient.addIncomingCallListener an anderer Stelle in Ihrer Android-App, hat dieser Listener Vorrang vor onIncomingCallüber die NexmoPushEventListener.
Schlussfolgerung
In diesem Leitfaden haben Sie gesehen, wie Sie Push-Benachrichtigungen einrichten können. Sie können auch ein Beispielprojekt finden, das die ConnectionService API und Push-Benachrichtigungen, um einen eingehenden Anruf über die Android-System-UI auf GitHub.