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

In diesem Leitfaden wird beschrieben, wie Sie Firebase Cloud Messaging in Ihren C++-Client-Apps einrichten, damit Sie Nachrichten zuverlässig senden können.

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. Für jede Plattform ist jedoch eine zusätzliche Einrichtung erforderlich. 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

Auf die Firebase-Installations-ID zugreifen

Registrierung mit Firebase-Installations-ID aktivieren

Damit Sie Ihre App-Instanz mit der Firebase-Installations-ID (FID) bei FCM registrieren können, müssen Sie zuerst FIDs in der Konfiguration Ihrer App für Android- und Apple-Plattformen aktivieren:

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

FirebaseMessagingInstallationIdEnabled = YES

onRegistrationReceived-Listener implementieren

Beim Initialisieren 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 erhält die FID mit dem OnRegistrationReceived-Callback, der in Ihrer firebase::messaging::Listener-Implementierung definiert sein 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 verwenden möchten, senden Sie die FID an Ihren App-Server und speichern Sie sie mit der gewünschten Methode.

Manuelle Registrierung, wenn die automatische Initialisierung deaktiviert ist

Sie können die Registrierung auch manuell mit FCM 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 Registrierungstoken für FCM zugreifen (veraltet)

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

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

Hinweis zur Nachrichtenzustellung unter Android

Wenn die App überhaupt 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 C++-Bibliotheks-Callback weiterleitet, müssen Sie die Methode onNewIntent in Ihrer Aktivität überschreiben und Intent an 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:

Benutzerdefinierte Nachrichtenverarbeitung unter Android

Standardmäßig werden an die App gesendete Benachrichtigungen an ::firebase::messaging::Listener::OnMessageReceived übergeben. In einigen Fällen möchten Sie das Standardverhalten jedoch möglicherweise ü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

Die ListenerService ist die Java-Klasse, die eingehende Nachrichten abfängt, die an die App gesendet werden, und sie an die C++-Bibliothek weiterleitet. Wenn sich die App im Vordergrund befindet (oder wenn sie sich im Hintergrund befindet und eine reine Daten-Payload empfängt), werden Nachrichten über einen der in dieser Klasse bereitgestellten Callbacks übergeben. 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 {

Durch Überschreiben der Methode ListenerService.onMessageReceived 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 auch überschrieben werden. Weitere Informationen finden Sie in der FirebaseMessagingService-Referenz.

@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 in AndroidManifest.xml aufgenommen werden, damit sie wirksam werden. Achten Sie darauf, dass das Manifest die Merge-Tools enthält, indem Sie das entsprechende Attribut im <manifest>-Tag deklarieren, wie hier gezeigt:

<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, in der die Standard-ListenerService von FCM deklariert wird. Dieses Manifest wird normalerweise mit dem projektspezifischen Manifest zusammengeführt, wodurch die ListenerService ausgeführt werden kann. ListenerService muss durch den benutzerdefinierten Listener-Dienst ersetzt werden. Dazu entfernen Sie die Standard-ListenerService und fügen den benutzerdefinierten Dienst hinzu. Das kann mit den folgenden Zeilen in der AndroidManifest.xml-Datei Ihres Projekts erfolgen:

<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 Version 7.1.0) wird JobIntentService verwendet. Das erfordert zusätzliche Änderungen in der Datei AndroidManifest.xml.

<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 von 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 einen Metadatenwert zu Ihrem Info.plist (nicht zu Ihrem GoogleService-Info.plist) auf Apple-Plattformen oder zu Ihrem AndroidManifest.xml auf Android hinzu:

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

FirebaseMessagingAutoInitEnabled = NO

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

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

Dieser Wert bleibt nach dem Festlegen auch nach Neustarts der App erhalten.

Nachrichten mit Deeplinks unter Android

Mit FCM können Nachrichten mit einem Deeplink in Ihre App gesendet werden. 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 abfangen. 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>

Sie können auch einen Platzhalter angeben, 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 zum 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