Wprowadzenie do Komunikacji w chmurze Firebase w aplikacjach w C++

Wybierz platformę: iOS+ Android Web Flutter Unity C++


Z tego przewodnika dowiesz się, jak zacząć korzystać z Firebase Cloud Messaging w aplikacjach klienckich w C++, aby niezawodnie wysyłać wiadomości.

Aby napisać wieloplatformową aplikację kliencką Firebase Cloud Messaging w C++, użyj interfejsu API Firebase Cloud Messaging. Pakiet SDK C++ działa zarówno na platformach Android, jak i Apple, ale na każdej z nich wymaga dodatkowej konfiguracji. Więcej informacji o tym, jak pakiet SDK C++ na iOS i Androida współpracuje z FCM, znajdziesz w artykule Firebase dla C++.

Konfiguracja Firebase i pakietu FCM SDK

Android

  1. Dodaj Firebase do projektu C++, jeśli nie korzystasz w nim jeszcze z tej usługi.

    • W połączonych instrukcjach konfiguracji sprawdź wymagania dotyczące urządzenia i aplikacji, które należy spełnić, aby używać pakietu SDK Firebase C++, w tym zalecenie dotyczące używania CMake do tworzenia aplikacji.

    • W pliku build.gradle na poziomie projektu dodaj repozytorium Maven Google w sekcjach buildscript i allprojects.

  2. Utwórz obiekt aplikacji w Firebase, przekazując środowisko JNI i Activity: 

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

  3. Zdefiniuj klasę, która implementuje interfejs firebase::messaging::Listener.

  4. Zainicjuj FCM, przekazując aplikację i utworzony obiekt Listener: 

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

  5. Aplikacje, które korzystają z pakietu SDK usług Google Play, powinny przed uzyskaniem dostępu do funkcji sprawdzić, czy na urządzeniu jest zgodny plik APK usług Google Play. Więcej informacji znajdziesz w artykule Sprawdzanie pakietu APK Usług Google Play.

iOS+

  1. Dodaj Firebase do projektu C++, jeśli nie korzystasz w nim jeszcze z tej usługi. Następnie, aby skonfigurować projekt dla FCM:
    1. W pliku Podfile projektu dodaj zależność FCM: 
      pod 'FirebaseMessaging'
    2. Przeciągnij platformy firebase.framework i firebase_messaging.framework do projektu Xcode z pakietu SDK Firebase C++.

  2. Prześlij klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APNs, utwórz go w Apple Developer Member Center.

    1. W konsoli Firebase kliknij Ustawienia > Ogólne. Następnie kliknij kartę Komunikacja w chmurze.
    2. W sekcji Klucz uwierzytelniania APNs w obszarze Konfiguracja aplikacji na iOS kliknij Prześlij, aby przesłać klucz uwierzytelniania programistycznego lub klucz uwierzytelniania produkcyjnego (albo oba te klucze). Trzeba podać co najmniej 1 formę kontaktu.
    3. Przejdź do lokalizacji, w której zapisano klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w Apple Developer Member Center) i kliknij Prześlij.

  3. Skonfiguruj projekt Xcode, aby włączyć powiadomienia push:

    1. Wybierz projekt w obszarze nawigatora.
    2. W obszarze edytora wybierz cel projektu.

    3. W obszarze edytora kliknij kartę Ogólne.

      1. Przewiń do sekcji Linked Frameworks and Libraries (Połączone platformy i biblioteki), a następnie kliknij przycisk +, aby dodać platformy.

      2. W wyświetlonym oknie przewiń do UserNotifications.framework, kliknij ten wpis, a następnie kliknij Dodaj.

        Ta platforma pojawia się tylko w Xcode w wersji 8 i nowszych i jest wymagana przez tę bibliotekę.

    4. W obszarze edytora wybierz kartę Capabilities (Możliwości).

      1. Ustaw Powiadomienia push w pozycji Włączone.
      2. Przewiń do opcji Tryby w tle i włącz ją.
      3. W sekcji Tryby działania w tle wybierz Powiadomienia zdalne.

  4. Utwórz obiekt aplikacji w Firebase: 

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

  5. Zdefiniuj klasę, która implementuje interfejs firebase::messaging::Listener.

  6. Zainicjuj Komunikację w chmurze Firebase, przekazując aplikację i utworzony obiekt nasłuchujący: 

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

Dostęp do identyfikatora instalacji Firebase

Włączanie rejestracji za pomocą identyfikatora instalacji Firebase

Aby umożliwić rejestrowanie instancji aplikacji w FCM za pomocą identyfikatora instalacji Firebase (FID), musisz najpierw włączyć identyfikatory FID w konfiguracji aplikacji na platformach Android i Apple:

Android

Dodaj element <meta-data> w elemencie <application> w pliku AndroidManifest.xml:

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

Swift

Dodaj klucz FirebaseMessagingInstallationIdEnabled do pliku Info.plist i ustaw go na YES:

FirebaseMessagingInstallationIdEnabled = YES

Implementowanie detektora onRegistrationReceived

Podczas inicjowania biblioteki Firebase Cloud Messaging rejestruje ona instancję aplikacji klienta, aby otrzymywać wiadomości za pomocą identyfikatora instalacji Firebase (FID). Aplikacja otrzyma identyfikator FID za pomocą wywołania zwrotnego OnRegistrationReceived, które powinno być zdefiniowane w implementacji firebase::messaging::Listener:

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

Jeśli chcesz kierować reklamy na konkretną instancję aplikacji, wyślij identyfikator FID na serwer aplikacji i zapisz go, używając preferowanej metody.

Ręczna rejestracja, gdy automatyczna inicjalizacja jest wyłączona

Możesz też ręcznie aktywować rejestrację za pomocą FCM w czasie działania, używając Register():

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

Dostęp do tokena rejestracji FCM (wycofany)

Po zainicjowaniu biblioteki Firebase Cloud Messaging instancja aplikacji klienckiej prosi o token rejestracji. Aplikacja otrzyma token z wywołaniem zwrotnym OnTokenReceived, które powinno być zdefiniowane w klasie implementującej firebase::messaging::Listener.

Jeśli chcesz kierować reklamy na tę konkretną instancję aplikacji, musisz mieć dostęp do tego tokena.

Uwaga dotycząca dostarczania wiadomości na Androidzie

Gdy aplikacja nie jest uruchomiona, a użytkownik kliknie powiadomienie, wiadomość nie jest domyślnie kierowana przez wbudowane wywołania zwrotne FCM. W takim przypadku ładunki wiadomości są odbierane przez obiekt Intent używany do uruchamiania aplikacji. Aby FCM przekazywał te wiadomości przychodzące do wywołania zwrotnego biblioteki C++, musisz zastąpić metodę onNewIntent w aktywności i przekazać Intent do MessageForwardingService.

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

Wiadomości otrzymane, gdy aplikacja działa w tle, mają treść pola powiadomienia, która jest używana do wypełnienia powiadomienia w obszarze powiadomień, ale ta treść nie zostanie przekazana do FCM. Oznacza to, że Message::notification będzie mieć wartość null.

W skrócie:

Stan aplikacji Powiadomienie Dane Oba rodzaje
Pierwszy plan OnMessageReceived OnMessageReceived OnMessageReceived
Tło Obszar powiadomień OnMessageReceived Powiadomienie: obszar powiadomień
Dane: w dodatkach intencji.

Obsługa wiadomości niestandardowych na Androidzie

Domyślnie powiadomienia wysyłane do aplikacji są przekazywane do ::firebase::messaging::Listener::OnMessageReceived, ale w niektórych przypadkach możesz chcieć zastąpić działanie domyślne. Aby to zrobić na Androidzie, musisz napisać niestandardowe klasy, które rozszerzają com.google.firebase.messaging.cpp.ListenerService, oraz zaktualizować plik AndroidManifest.xml projektu.

Zastąp metody ListenerService

ListenerService to klasa Javy, która przechwytuje wiadomości przychodzące wysyłane do aplikacji i przekierowuje je do biblioteki C++. Gdy aplikacja działa na pierwszym planie (lub gdy działa w tle i otrzymuje ładunek zawierający tylko dane), wiadomości będą przekazywane przez jedno z wywołań zwrotnych udostępnianych w tej klasie. Aby dodać niestandardowe zachowanie do obsługi wiadomości, musisz rozszerzyć domyślny ListenerService FCM:

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

class MyListenerService extends ListenerService {

Zastępując metodę ListenerService.onMessageReceived, możesz wykonywać działania na podstawie otrzymanego obiektu RemoteMessage i pobierać dane wiadomości:

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

ListenerService ma też kilka innych metod, które są używane rzadziej. Można je również zastąpić. Więcej informacji znajdziesz w dokumentacji 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);
}

Aktualizacja reguły AndroidManifest.xml

Po utworzeniu klas niestandardowych należy je uwzględnić w pliku AndroidManifest.xml, aby zaczęły obowiązywać. Upewnij się, że plik manifestu zawiera narzędzia łączące, deklarując odpowiedni atrybut w tagu <manifest>, na przykład:

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

W archiwum firebase_messaging_cpp.aar znajduje się plik AndroidManifest.xml, który deklaruje domyślny ListenerService FCM. Ten plik manifestu jest zwykle scalany z plikiem manifestu projektu, co umożliwia działanie ListenerService. Ten element ListenerService należy zastąpić niestandardową usługą detektora. Można to zrobić, usuwając domyślną usługę ListenerService i dodając usługę niestandardową. W tym celu dodaj do pliku AndroidManifest.xml projektu te wiersze:

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

Nowe wersje pakietu Firebase C++ SDK (od wersji 7.1.0) używają JobIntentService, co wymaga dodatkowych modyfikacji w pliku AndroidManifest.xml.

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

Zapobieganie automatycznej inicjalizacji

FCM generuje token rejestracji na potrzeby kierowania na instancję aplikacji. Po wygenerowaniu tokena biblioteka przesyła identyfikator i dane konfiguracji do Firebase. Jeśli chcesz uzyskać wyraźną zgodę przed użyciem tokena, możesz uniemożliwić jego wygenerowanie podczas konfiguracji, wyłączając FCM (oraz Analytics na Androidzie). Aby to zrobić, dodaj wartość metadanych do pliku Info.plist (nie GoogleService-Info.plist) na platformach Apple lub do pliku AndroidManifest.xml na Androidzie:

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

Aby ponownie włączyć FCM, możesz wykonać wywołanie w czasie działania:

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

Po ustawieniu ta wartość jest zachowywana po ponownym uruchomieniu aplikacji.

FCM umożliwia wysyłanie wiadomości zawierających precyzyjny link do aplikacji. Aby otrzymywać wiadomości zawierające precyzyjny link, musisz dodać nowy filtr intencji do aktywności, która obsługuje precyzyjne linki w aplikacji. Filtr intencji powinien przechwytywać precyzyjne linki z Twojej domeny. Jeśli Twoje wiadomości nie zawierają precyzyjnego linku, ta konfiguracja nie jest konieczna. W pliku 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>

Możesz też określić symbol wieloznaczny, aby filtr intencji był bardziej elastyczny. Przykład:

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

Gdy użytkownicy klikną powiadomienie zawierające link do określonego przez Ciebie schematu i hosta, aplikacja rozpocznie działanie z tym filtrem intencji, aby obsłużyć link.

Dalsze kroki

Po wykonaniu czynności konfiguracyjnych możesz zacząć korzystać z FCM w C++ na kilka sposobów: