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

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


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

Aby napisać aplikację kliencką na wielu platformach Firebase Cloud Messaging w języku C++, użyj Firebase Cloud Messaging interfejsu API. Pakiet SDK C++ działa na platformach Android i Apple, ale w przypadku każdej z nich wymagana jest dodatkowa konfiguracja. Więcej informacji o tym, jak pakiet SDK C++ na iOS i Androida współpracuje z FCM, znajdziesz w artykule Informacje o Firebase dla C++.

Konfigurowanie Firebase i pakietu SDK FCM

Android

  1. Jeśli jeszcze tego nie zrobisz, dodaj Firebase do projektu C++.

    • W połączonych instrukcjach konfiguracji zapoznaj się z wymaganiami dotyczącymi urządzeń i aplikacji w przypadku korzystania z pakietu SDK Firebase C++, w tym z zaleceniem używania CMake do tworzenia aplikacji.

    • W pliku build.gradle na poziomie projektu upewnij się, że repozytorium Google Maven jest uwzględnione w sekcjach buildscript i allprojects.

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

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

    ::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 zainstalowany zgodny plik APK Usług Google Play. Więcej informacji znajdziesz w artykule Sprawdzanie, czy na urządzeniu jest zainstalowany plik APK Usług Google Play.

iOS+

  1. Jeśli jeszcze tego nie zrobisz, dodaj Firebase do projektu C++. Następnie, aby skonfigurować projekt pod kątem FCM:
    1. W pliku Podfile projektu dodaj zależność FCM: 
      pod 'FirebaseMessaging'
    2. Przeciągnij frameworki 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 otwórz 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 do programowania lub klucz uwierzytelniania do produkcji albo oba te klucze. Wymagany jest co najmniej 1 klucz.
    3. Otwórz lokalizację, w której został zapisany 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. Wybierz cel projektu w obszarze edytora.

    3. Wybierz kartę Ogólne w obszarze edytora.

      1. Przewiń do sekcji Połączone frameworki i biblioteki, a następnie kliknij przycisk +, aby dodać frameworki.

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

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

    4. Wybierz kartę Możliwości w obszarze edytora.

      1. Przełącz Powiadomienia push na Włączone.
      2. Przewiń do sekcji Tryby działania w tle, a następnie przełącz ją na Włączone.
      3. W sekcji Tryby działania w tle wybierz Powiadomienia zdalne.

  4. Utwórz obiekt aplikacji 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 odbiornik: 

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

Uzyskiwanie dostępu do tokena rejestracji FCM

Po zainicjowaniu biblioteki Komunikacji w chmurze Firebase wysyłane jest żądanie tokena rejestracji dla instancji aplikacji klienckiej. Aplikacja otrzyma token za pomocą wywołania zwrotnego 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 na temat dostarczania wiadomości na Androida

Gdy aplikacja nie jest w ogóle uruchomiona, a użytkownik kliknie powiadomienie, wiadomość domyślnie nie jest kierowana przez FCM's wbudowane wywołania zwrotne. W takim przypadku ładunki wiadomości są odbierane za pomocą Intent używanego do uruchamiania aplikacji. Aby FCM przekazywał te przychodzące wiadomości do wywołania zwrotnego biblioteki C++, musisz zastąpić metodę onNewIntent w swojej 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 odbierane, gdy aplikacja działa w tle, mają treść pola powiadomienia używaną do wypełniania powiadomienia w obszarze powiadomień, ale ta treść powiadomienia nie będzie przekazywana 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 do intencji.

Niestandardowa obsługa wiadomości na Androida

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

Zastępowanie metod ListenerService

ListenerService to klasa Java, która przechwytuje przychodzące wiadomości wysyłane do aplikacji i kieruje je do biblioteki C++. Gdy aplikacja działa na pierwszym planie (lub gdy działa w tle i odbiera ładunek zawierający tylko dane), wiadomości będą przechodzić przez jedno z wywołań zwrotnych udostępnianych w tej klasie. Aby dodać niestandardowe działanie do obsługi wiadomości, musisz rozszerzyć FCM's domyślną usługę 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);
}

Aktualizowanie pliku AndroidManifest.xml

Gdy napiszesz niestandardowe klasy, musisz je uwzględnić w pliku AndroidManifest.xml, aby zaczęły działać. Upewnij się, że manifest zawiera narzędzia do scalania, deklarując odpowiedni atrybut w tagu <manifest>:

<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ślną usługę FCM ListenerService. Ten manifest jest zwykle scalany z manifestem specyficznym dla projektu, dzięki czemu usługa ListenerService może działać. Tę usługę ListenerService trzeba zastąpić niestandardową usługą odbiornika. Aby to zrobić, usuń domyślną usługę ListenerService i dodaj niestandardową usługę, co możesz zrobić za pomocą tych wierszy w 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 Firebase C++ SDK (od 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 reklam na instancję aplikacji. Gdy token zostanie wygenerowany, biblioteka prześle identyfikator i dane konfiguracyjne do Firebase. Jeśli chcesz uzyskać wyraźną zgodę przed użyciem tokena, możesz zapobiec jego wygenerowaniu podczas konfigurowania, wyłączając FCM (a na Androidzie – Analytics). Aby to zrobić, dodaj wartość metadanych do pliku Info.plist (nie do pliku 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::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 w 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ż użyć symbolu wieloznacznego, 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 schematu i hosta, które określisz, Twoja aplikacja uruchomi aktywność z tym filtrem intencji, aby obsłużyć link.

Dalsze kroki

Po wykonaniu czynności konfiguracyjnych możesz przejść do dalszych działań związanych z FCM dla C++: