Konfigurowanie aplikacji klienckiej Komunikacja w chmurze Firebase (FCM) w języku C++

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.

Konfigurowanie Firebase i pakietu SDK FCM

Android

  1. Jeśli nie zostało to jeszcze zrobione, dodaj Firebase do projektu C++.

    • W linkowanych instrukcjach konfiguracji sprawdź wymagania dotyczące urządzenia i aplikacji dotyczące korzystania z pakietu SDK Firebase C++, w tym zalecenie używania CMake do kompilowania aplikacji.

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

  2. Utwórz obiekt Firebase App, przekazując środowisko JNI i działanie:

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

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

  4. Inicjuj FCM, przekazując App i skonstruowanego Listenera: 

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

  5. Aplikacje korzystające z pakietu SDK Usług Google Play powinny sprawdzić na urządzeniu, czy jest dostępny zgodny plik APK Usług Google Play, zanim uzyskają dostęp do funkcji. Więcej informacji znajdziesz w artykule Sprawdzanie pliku APK Usług Google Play.

iOS+

  1. Jeśli nie zostało to jeszcze zrobione, dodaj Firebase do projektu C++. Następnie, aby skonfigurować projekt dla FCM:
    1. W pliku Podfile projektu dodaj zależność FCM: 
      pod 'FirebaseMessaging'
    2. Przeciągnij do projektu Xcode biblioteki firebase.framework i firebase_messaging.framework z Firebase C++ SDK.

  2. Prześlij klucz uwierzytelniania APNs do Firebase. Jeśli nie masz jeszcze klucza uwierzytelniania APN, utwórz go w Centrum dla deweloperów Apple.

    1. W konsoli Firebase projektu kliknij ikonę koła zębatego, wybierz Ustawienia projektu, a następnie kartę Cloud Messaging.

    2. W sekcji Konfiguracja aplikacji na iOS kliknij Prześlij obok Klucz uwierzytelniania APNs.

    3. Przejdź do lokalizacji, w której został zapisany klucz, wybierz go i kliknij Otwórz. Dodaj identyfikator klucza (dostępny w  Centrum dla deweloperów Apple) i kliknij Prześlij.

  3. Aby włączyć powiadomienia push, skonfiguruj projekt Xcode:

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

    3. W sekcji Obszar edytora kliknij kartę Ogólne.

      1. Przewiń w dół do sekcji Połączone platformy i biblioteki, a potem kliknij przycisk +, aby dodać platformy.

      2. W wyświetlonym oknie przewiń do pozycji UserNotifications.framework, kliknij ten wpis, a potem kliknij Dodaj.

        Ten framework jest dostępny tylko w Xcode w wersji 8 i nowszej i jest wymagany przez tę bibliotekę.

    4. W sekcji Obszar edytora kliknij kartę Możliwości.

      1. Przełącz Powiadomienia push w pozycji Wł..
      2. Przewiń w dół do sekcji Tryby działania w tle, a potem ustaw ją na Wł..
      3. W sekcji Tryby w tle wybierz Powiadomienia zdalne.

  4. Utwórz obiekt Aplikacja Firebase: 

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

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

  6. Inicjalizacja Komunikacji w chmurze Firebase z przekazaniem aplikacji i skonstruowanego obiektu Listener:

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

Dostęp do tokena rejestracji urządzenia

Po zainicjowaniu biblioteki Komunikacji w chmurze Firebase żąda się tokenu rejestracji dla instancji aplikacji klienta. Aplikacja otrzyma token za pomocą wywołania zwrotnego OnTokenReceived, który powinien być zdefiniowany w klasie implementującej firebase::messaging::Listener.

Jeśli chcesz kierować reklamy na to konkretne urządzenie, musisz mieć dostęp do tego tokena.

Uwaga dotycząca dostarczania wiadomości na urządzeniach z Androidem

Gdy aplikacja nie jest w ogóle uruchomiona, a użytkownik kliknie powiadomienie, domyślnie wiadomość nie jest kierowana przez wbudowane wywołania zwrotne FCM. W takim przypadku ładunki wiadomości są odbierane przez Intentużywany do uruchamiania aplikacji. Aby funkcja FCM przekazywała te przychodzące wiadomości do funkcji zwracanej biblioteki C++, musisz zastąpić metodę onNewIntent w swojej aktywności i przekazać parametr Intent do funkcji 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 odbierane, gdy aplikacja działa w tle, mają treść w polu powiadomienia, która jest używana do wypełniania powiadomienia w obszarze powiadomień, ale jej treść nie jest przekazywana do FCM. Oznacza to, że Message::notification będzie wartością null.

W skrócie:

Stan aplikacji Powiadomienie Dane Oba rodzaje
Pierwszy plan OnMessageReceived OnMessageReceived OnMessageReceived
Tło obszar powiadomień. OnMessageReceived Powiadomienie: pasek systemowy
Dane: w dodatkowych informacjach intencji.

Postępowanie z wiadomościami niestandardowymi na Androidzie

Domyślnie powiadomienia wysyłane do aplikacji są przekazywane do funkcji ::firebase::messaging::Listener::OnMessageReceived, ale w niektórych przypadkach możesz chcieć zmienić domyślne zachowanie. Aby to zrobić na Androidzie, musisz napisać klasy niestandardowe rozszerzające klasę com.google.firebase.messaging.cpp.ListenerService, a także zaktualizować plik AndroidManifest.xml projektu.

Zastąp metody ListenerService.

ListenerService to klasa Java, która przechwytuje przychodzące wiadomości 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 dane tylko z ładunku), wiadomości są przekazywane przez jedną z funkcji wywołania zwrotnego udostępnionych w tej klasie. Aby dodać niestandardowe zachowanie do obsługi wiadomości, musisz rozszerzyć domyślną funkcję FCM: ListenerService:

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

Zaktualizuj: AndroidManifest.xml

Po napisaniu niestandardowych klas należy je uwzględnić w definicji AndroidManifest.xml, aby zaczęły obowiązywać. Upewnij się, że manifest zawiera narzędzia do scalania, deklarując odpowiedni atrybut w tagu <manifest>, na przykład w ten sposób:

<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 określa domyślny ListenerService dla FCM. Ten plik manifestu jest zwykle scalany z pliku manifestu konkretnego projektu, dzięki czemu można uruchomić usługę ListenerService. Ten element ListenerService należy zastąpić elementem usługi listenera niestandardowego. Aby to zrobić, usuń domyślną usługę ListenerService i dodaj niestandardową usługę. Możesz to zrobić, dodając te wiersze do pliku AndroidManifest.xml projektu:

<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 SDK Firebase w C++ (od wersji 7.1.0) korzystają z poziomu JobIntentService, co wymaga wprowadzenia 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 urządzenia. Gdy wygenerowany zostanie token, biblioteka prześle do Firebase identyfikator i dane konfiguracji. Jeśli chcesz uzyskać wyraźną zgodę przed użyciem tokena, możesz uniemożliwić wygenerowanie go w momencie konfiguracji, wyłączając FCM (a w przypadku Androida – też Analytics). Aby to zrobić, dodaj wartość metadanych do Info.plist (a nie GoogleService-Info.plist) na platformach Apple lub do 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 wywołać go w czasie wykonywania:

::firebase::messaging::SetTokenRegistrationOnInitEnabled(true);

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

FCM umożliwia wysyłanie wiadomości zawierających precyzyjny link do Twojej aplikacji. Aby otrzymywać wiadomości zawierające precyzyjny link, musisz dodać nowy filtr intencji do aktywności, która obsługuje precyzyjne linki do Twojej aplikacji. Filtr intencji powinien przechwytywać precyzyjne linki do 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 uczynić filtr intencji bardziej elastycznym. 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 schematu i hosta, Twoja aplikacja rozpocznie działanie za pomocą filtra intencji, aby obsłużyć ten link.

Dalsze kroki

Po skonfigurowaniu aplikacji klienta możesz wysyłać wiadomości do podrzędnych i tematycznych za pomocą Firebase. Więcej informacji o tej funkcji znajdziesz w pliku przykładowym „Szybki start”, który możesz pobrać, uruchomić i przeanalizować.

Aby dodać do aplikacji inne, bardziej zaawansowane funkcje, zapoznaj się z tymi przewodnikami dotyczącymi wysyłania wiadomości z serwera aplikacji:

Aby korzystać z tych funkcji, musisz mieć implementację na serwerze.