Erste Schritte mit Firebase Cloud Messaging in C++-Apps

Plattform auswählen:

iOS+ Android Web Flutter Unity C++

In diesem Leitfaden wird beschrieben, wie Sie Firebase Cloud Messaging in Ihren C++-Client-Apps verwenden, um Nachrichten zuverlässig zu senden.

Wenn Sie Ihre plattformübergreifende Firebase Cloud Messaging-Client-App mit C++ schreiben möchten, verwenden Sie die Firebase Cloud Messaging API. Das C++ SDK funktioniert sowohl für Android- als auch für Apple-Plattformen, wobei für jede Plattform eine zusätzliche Einrichtung erforderlich ist. Weitere Informationen zur Funktionsweise des C++ SDK für iOS und Android mit FCM finden Sie unter Firebase für C++.

Firebase und das FCM SDK einrichten

Android

1. Falls noch nicht geschehen, fügen Sie Ihrem C++-Projekt Firebase hinzu.

   • In der verlinkten Einrichtungsanleitung findest du die Geräte- und App-Anforderungen für die Verwendung des Firebase C++ SDK, einschließlich der Empfehlung, CMake zum Erstellen deiner App zu verwenden.

   • Fügen Sie in der Datei build.gradle auf Projektebene das Maven-Repository von Google sowohl im Abschnitt buildscript als auch im Abschnitt allprojects ein.

   Wichtig: Fügen Sie die Bibliothek firebase_messaging in die Datei CMakeLists.txt ein.

2. Erstellen Sie ein Firebase-App-Objekt und übergeben Sie die JNI-Umgebung und die Aktivität:

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

3. Definieren Sie eine Klasse, die die Schnittstelle firebase::messaging::Listener implementiert.

4. Initialisieren Sie FCM und übergeben Sie die App und einen erstellten Listener:

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

5. Apps, die das Google Play-Dienste SDK verwenden, sollten das Gerät auf ein kompatibles Google Play-Dienste APK prüfen, bevor sie auf die Funktionen zugreifen. Weitere Informationen finden Sie unter Nach Google Play-Dienste-APK suchen.

iOS+

1. Falls noch nicht geschehen, fügen Sie Ihrem C++-Projekt Firebase hinzu. So richten Sie Ihr Projekt für FCM ein:
   1. Fügen Sie in der Podfile-Datei Ihres Projekts die FCM-Abhängigkeit hinzu:

      pod 'FirebaseMessaging'

   2. Ziehen Sie die Frameworks firebase.framework und firebase_messaging.framework aus dem Firebase C++ SDK in Ihr Xcode-Projekt.

2. Laden Sie Ihren APNs-Authentifizierungsschlüssel in Firebase hoch. Wenn Sie noch keinen APNs-Authentifizierungsschlüssel haben, erstellen Sie einen im Apple Developer Member Center.

   1. Rufen Sie in der Firebase Console die Einstellungen > Allgemein auf. Klicken Sie dann auf den Tab Cloud Messaging.
   2. Klicken Sie unter iOS-App-Konfiguration bei APNs-Authentifizierungsschlüssel auf Hochladen, um den Entwicklungs-Authentifizierungsschlüssel, den Produktions-Authentifizierungsschlüssel oder beide hochzuladen. Mindestens eine Angabe ist erforderlich.
   3. Suchen Sie den Speicherort, an dem Sie Ihren Schlüssel gespeichert haben, wählen Sie ihn aus und klicken Sie auf Öffnen. Fügen Sie die Schlüssel-ID für den Schlüssel hinzu (verfügbar im Apple Developer Member Center) und klicken Sie auf Hochladen.

3. Konfigurieren Sie Ihr Xcode-Projekt, um Push-Benachrichtigungen zu aktivieren:

   1. Wählen Sie das Projekt im Navigatorbereich aus.
   2. Wählen Sie im Editorbereich das Projektziel aus.

   3. Wählen Sie im Editorbereich den Tab Allgemein aus.

      1. Scrollen Sie zu Linked Frameworks and Libraries (Verknüpfte Frameworks und Bibliotheken) und klicken Sie auf den Button +, um Frameworks hinzuzufügen.

      2. Scrollen Sie im angezeigten Fenster zu UserNotifications.framework, klicken Sie auf den Eintrag und dann auf Hinzufügen.

         Dieses Framework wird nur in Xcode v8 und höher angezeigt und ist für diese Bibliothek erforderlich.

   4. Wählen Sie im Editorbereich den Tab Funktionen aus.

      1. Stelle Push-Benachrichtigungen auf An.
      2. Scrolle zu Hintergrundmodi und aktiviere die Option.
      3. Wählen Sie unter Background Modes (Hintergrundmodi) die Option Remote notifications (Remote-Benachrichtigungen) aus.

4. Erstellen Sie ein Firebase-App-Objekt:

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

5. Definieren Sie eine Klasse, die die Schnittstelle firebase::messaging::Listener implementiert.

6. Initialisieren Sie Firebase Cloud Messaging und übergeben Sie die App und einen erstellten Listener:

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

Auf die Firebase-Installations-ID zugreifen

Hinweis: Firebase Cloud Messaging stellt von FCM-Registrierungstokens auf Firebase-Installations-IDs (FIDs) um, um einzelne App-Instanzen anzusprechen.

Registrierung mit Firebase-Installations-ID aktivieren

Wenn Sie die Registrierung Ihrer App-Instanz bei FCM mit der Firebase-Installations-ID (FID) aktivieren möchten, müssen Sie zuerst FIDs in der Konfiguration Ihrer App für Android- und Apple-Plattformen aktivieren:

Android

Fügen Sie das folgende <meta-data>-Element im <application>-Element Ihrer AndroidManifest.xml hinzu:

<meta-data android:name="firebase_messaging_installation_id_enabled"
           android:value="true" />

Swift

Fügen Sie den Schlüssel FirebaseMessagingInstallationIdEnabled zu Info.plist hinzu und setzen Sie ihn auf YES:

FirebaseMessagingInstallationIdEnabled = YES

onRegistrationReceived-Listener implementieren

Bei der Initialisierung der Firebase Cloud Messaging-Bibliothek wird die Client-App-Instanz für den Empfang von Nachrichten mit einer Firebase-Installations-ID (FID) registriert. Die App empfängt die FID mit dem Callback OnRegistrationReceived, der in Ihrer firebase::messaging::Listener-Implementierung definiert werden sollte:

class MyListener : public firebase::messaging::Listener {
 public:
  void OnRegistrationReceived(const char* installation_id) override {
    LogMessage("Received Firebase Installation ID: %s", installation_id);
    // TODO: Send the Firebase Installation ID (FID) to your app server to
    // target this device for messages.
  }
};

Wenn Sie diese bestimmte App-Instanz als Ziel festlegen möchten, senden Sie die FID an Ihren App-Server und speichern Sie sie mit der von Ihnen bevorzugten Methode.

Manuelle Registrierung, wenn die automatische Initialisierung deaktiviert ist

Sie können die Registrierung mit FCM auch manuell zur Laufzeit mit Register() auslösen:

// Manually register with FCM
firebase::Future<void> register_future = firebase::messaging::Register();
register_future.OnCompletion([](const firebase::Future<void>& future) {
  if (future.status() == firebase::kFutureStatusComplete &&
      future.error() == 0) {
    // Note: The registered Firebase Installation ID is delivered to the
    // OnRegistrationReceived callback.
    LogMessage("Registered with FCM");
  }
});

Auf das FCM-Registrierungstoken zugreifen (verworfen)

Achtung: Diese Funktion wurde eingestellt. Verwenden Sie Firebase-Installations-IDs, da diese Methode in einem zukünftigen Release entfernt wird.

Bei der Initialisierung der Firebase Cloud Messaging-Bibliothek wird ein Registrierungstoken für die Client-App-Instanz angefordert. Die App empfängt das Token mit dem Callback OnTokenReceived, der in der Klasse definiert werden sollte, die firebase::messaging::Listener implementiert.

Wenn Sie diese bestimmte App-Instanz als Ziel festlegen möchten, benötigen Sie Zugriff auf dieses Token.

Hinweis zur Nachrichtenzustellung auf Android-Geräten

Wenn die App gar nicht ausgeführt wird und ein Nutzer auf eine Benachrichtigung tippt, wird die Nachricht standardmäßig nicht über die integrierten Callbacks von FCM weitergeleitet. In diesem Fall werden Nachrichtennutzlasten über einen Intent empfangen, der zum Starten der Anwendung verwendet wird. Damit FCM diese eingehenden Nachrichten an den Callback der C++-Bibliothek weiterleitet, müssen Sie die Methode onNewIntent in Ihrer Aktivität überschreiben und die Intent an die MessageForwardingService übergeben.

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

Bei Nachrichten, die empfangen werden, während die App im Hintergrund ausgeführt wird, wird der Inhalt des Benachrichtigungsfelds verwendet, um die Benachrichtigung in der Taskleiste zu füllen. Dieser Benachrichtigungsinhalt wird jedoch nicht an FCM weitergegeben. Das heißt, Message::notification ist null.

Zusammenfassung:

App-Status	Benachrichtigung	Daten	Beides
Vordergrund	OnMessageReceived	OnMessageReceived	OnMessageReceived
Hintergrund	Taskleiste	OnMessageReceived	Benachrichtigung: Taskleiste Daten: in den Extras des Intents.

Benutzerdefinierte Nachrichtenverarbeitung unter Android

Standardmäßig werden an die App gesendete Benachrichtigungen an ::firebase::messaging::Listener::OnMessageReceived weitergeleitet. In einigen Fällen kann es jedoch sinnvoll sein, das Standardverhalten zu überschreiben. Dazu müssen Sie unter Android benutzerdefinierte Klassen schreiben, die com.google.firebase.messaging.cpp.ListenerService erweitern, und die AndroidManifest.xml Ihres Projekts aktualisieren.

ListenerService-Methoden überschreiben

ListenerService ist die Java-Klasse, die eingehende Nachrichten an die App abfängt und an die C++-Bibliothek weiterleitet. Wenn sich die App im Vordergrund befindet (oder wenn sie sich im Hintergrund befindet und eine reine Datennutzlast empfängt), werden Nachrichten über einen der in dieser Klasse bereitgestellten Callbacks weitergeleitet. Wenn Sie der Nachrichtenverarbeitung benutzerdefiniertes Verhalten hinzufügen möchten, müssen Sie die Standard-ListenerService von FCM erweitern:

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

class MyListenerService extends ListenerService {

Wenn Sie die Methode ListenerService.onMessageReceived überschreiben, können Sie Aktionen basierend auf dem empfangenen RemoteMessage-Objekt ausführen und die Nachrichtendaten abrufen:

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

ListenerService hat auch einige andere Methoden, die seltener verwendet werden. Diese können ebenfalls überschrieben werden. Weitere Informationen finden Sie in der Referenz zu 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);
}

AndroidManifest.xml aktualisieren

Nachdem Sie Ihre benutzerdefinierten Klassen geschrieben haben, müssen Sie sie in die AndroidManifest.xml aufnehmen, damit sie wirksam werden. Achte darauf, dass das Manifest die Merger-Tools enthält, indem du das entsprechende Attribut im <manifest>-Tag deklarierst, z. B. so:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.google.firebase.messaging.cpp.samples"
    xmlns:tools="http://schemas.android.com/tools">

Im Archiv firebase_messaging_cpp.aar befindet sich eine AndroidManifest.xml-Datei, die die Standard-ListenerService von FCM deklariert. Dieses Manifest wird normalerweise mit dem projektspezifischen Manifest zusammengeführt, damit der ListenerService ausgeführt werden kann. Dieser ListenerService muss durch den benutzerdefinierten Listener-Dienst ersetzt werden. Dazu entfernen Sie den Standard-ListenerService und fügen den benutzerdefinierten Dienst hinzu. Das können Sie mit den folgenden Zeilen in der Datei AndroidManifest.xml Ihres Projekts tun:

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

In neuen Versionen des Firebase C++ SDK (ab 7.1.0) wird JobIntentService verwendet, was zusätzliche Änderungen in der Datei AndroidManifest.xml erfordert.

<service android:name="com.google.firebase.messaging.MessageForwardingService"
     android:permission="android.permission.BIND_JOB_SERVICE"
     android:exported="false" >
</service>

Automatische Initialisierung verhindern

FCM generiert ein Registrierungstoken für das Targeting auf App-Instanzen. Wenn ein Token generiert wird, lädt die Bibliothek die Kennung und die Konfigurationsdaten in Firebase hoch. Wenn Sie vor der Verwendung des Tokens eine explizite Einwilligung einholen möchten, können Sie die Generierung bei der Konfiguration verhindern, indem Sie FCM (und unter Android Analytics) deaktivieren. Fügen Sie dazu auf Apple-Plattformen einen Metadatenwert zu Info.plist (nicht zu GoogleService-Info.plist) oder auf Android-Plattformen zu AndroidManifest.xml hinzu:

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>

Swift

FirebaseMessagingAutoInitEnabled = NO

Wenn Sie FCM wieder aktivieren möchten, können Sie einen Laufzeitaufruf ausführen:

::firebase::messaging::SetRegistrationOnInitEnabled(true);

Hinweis: SetTokenRegistrationOnInitEnabled wurde eingestellt. Verwenden Sie stattdessen SetRegistrationOnInitEnabled.

Dieser Wert bleibt nach dem Festlegen auch bei einem Neustart der App erhalten.

Nachrichten mit Deeplinks auf Android-Geräten

Mit FCM können Nachrichten gesendet werden, die einen Deeplink zu Ihrer App enthalten. Wenn Sie Nachrichten mit einem Deeplink empfangen möchten, müssen Sie der Aktivität, die Deeplinks für Ihre App verarbeitet, einen neuen Intent-Filter hinzufügen. Der Intent-Filter sollte Deeplinks Ihrer Domain erfassen. Wenn Ihre Nachrichten keinen Deeplink enthalten, ist diese Konfiguration nicht erforderlich. In 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>

Es ist auch möglich, einen Platzhalter anzugeben, um den Intent-Filter flexibler zu gestalten. Beispiel:

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

Wenn Nutzer auf eine Benachrichtigung mit einem Link zu dem von Ihnen angegebenen Schema und Host tippen, startet Ihre App die Aktivität mit diesem Intent-Filter, um den Link zu verarbeiten.

Nächste Schritte

Nachdem Sie die Einrichtungsschritte abgeschlossen haben, haben Sie folgende Möglichkeiten, mit FCM für C++ fortzufahren:

• Nachrichten an Geräte senden
• Nachrichten in einer C++-App empfangen
• Nachrichten an Themen senden