Skonfiguruj aplikację kliencką Firebase Cloud Messaging w języku C++

Aby napisać wieloplatformową aplikację kliencką Firebase Cloud Messaging w języku C++, użyj interfejsu API Firebase Cloud Messaging . Zestaw SDK języka C++ działa zarówno na platformach Android, jak i Apple, a dla każdej platformy wymagana jest dodatkowa konfiguracja.

Skonfiguruj Firebase i pakiet SDK FCM

Android

  1. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu C++ .

    • W połączonych instrukcjach konfiguracji przejrzyj wymagania dotyczące urządzenia i aplikacji dotyczące korzystania z pakietu SDK Firebase C++, w tym zalecenia dotyczące używania CMake do tworzenia aplikacji.

    • W pliku build.gradle na poziomie projektu pamiętaj o uwzględnieniu repozytorium Google Maven zarówno w sekcji buildscript , jak i allprojects .

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

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

  3. Zdefiniuj klasę implementującą interfejs firebase::messaging::Listener .

  4. Zainicjuj FCM, przekazując aplikację i skonstruowanego słuchacza:

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

  5. Aplikacje korzystające z pakietu SDK Usług Google Play powinny sprawdzić, czy na urządzeniu znajduje się zgodny plik APK Usług Google Play, zanim uzyskają dostęp do tych funkcji. Aby dowiedzieć się więcej, zobacz Sprawdź dostępność pakietu APK Usług Google Play .

iOS+

  1. Potrzebujesz ważnego certyfikatu APNs . Jeśli jeszcze go nie masz, utwórz go w Apple Developer Member Center .
  2. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu C++ . Następnie, aby skonfigurować projekt dla FCM:
    1. W pliku Podfile swojego projektu dodaj zależność FCM:
      pod 'FirebaseMessaging'
    2. Przeciągnij struktury firebase.framework i firebase_messaging.framework do swojego projektu Xcode z zestawu SDK Firebase C++ .
  3. Skonfiguruj swój projekt Xcode, aby włączyć powiadomienia push:

    1. Wybierz projekt z obszaru Nawigatora .
    2. Wybierz cel projektu z obszaru Edytor .
    3. Wybierz kartę Ogólne z obszaru Edytor .

      1. Przewiń w dół do opcji Połączone struktury i biblioteki , a następnie kliknij przycisk + , aby dodać struktury.
      2. W wyświetlonym oknie przewiń do UserNotifications.framework , kliknij ten wpis, a następnie kliknij Dodaj .

        Ta struktura pojawia się tylko w Xcode v8 i nowszych wersjach i jest wymagana przez tę bibliotekę.

    4. Wybierz zakładkę Możliwości z obszaru Edytor .

      1. Przełącz opcję Powiadomienia push na wartość Włączone .
      2. Przewiń w dół do opcji Tryby tła , a następnie przełącz ją na opcję Włączone .
      3. Wybierz opcję Powiadomienia zdalne w obszarze Tryby tła .
  4. Utwórz obiekt aplikacji Firebase:

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

  5. Zdefiniuj klasę implementującą interfejs firebase::messaging::Listener .

  6. Zainicjuj Firebase Cloud Messaging, przekazując aplikację i skonstruowanego odbiornika:

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

Uzyskaj dostęp do tokena rejestracji urządzenia

Po zainicjowaniu biblioteki Firebase Cloud Messaging żądany jest token rejestracji dla instancji aplikacji klienckiej. Aplikacja otrzyma token wraz z wywołaniem zwrotnym OnTokenReceived , które należy zdefiniować w klasie implementującej firebase::messaging::Listener .

Jeśli chcesz kierować reklamy na to konkretne urządzenie, będziesz potrzebować dostępu do tego tokena.

Uwaga dotycząca dostarczania wiadomości w systemie Android

Gdy aplikacja w ogóle nie jest uruchomiona, a użytkownik kliknie powiadomienie, wiadomość nie jest domyślnie kierowana przez wbudowane wywołania zwrotne FCM. W tym przypadku ładunki komunikatów są odbierane poprzez Intent używaną do uruchomienia aplikacji. Aby FCM przekazywał te przychodzące wiadomości do wywołania zwrotnego biblioteki C++, musisz zastąpić metodę onNewIntent w swoim działaniu 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, zawierają treść pola powiadomień służącą do wypełnienia powiadomienia w zasobniku systemowym, ale treść powiadomienia nie będzie przekazywana do FCM. Oznacza to, że Message::notification będzie mieć wartość null.

W podsumowaniu:

Stan aplikacji Powiadomienie Dane Obydwa
Pierwszoplanowy OnMessageReceived OnMessageReceived OnMessageReceived
Tło Taca systemowa OnMessageReceived Powiadomienie: zasobnik systemowy
Dane: w dodatkach intencji.

Niestandardowa obsługa wiadomości w systemie Android

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

Zastąp metody ListenerService .

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

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

class MyListenerService extends ListenerService {

Nadpisując metodę ListenerService.onMessageReceived , możesz wykonać akcje na podstawie odebranego obiektu RemoteMessage i uzyskać 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 również kilka innych metod, które są rzadziej używane. Można je również zastąpić. Więcej informacji można znaleźć 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 plik AndroidManifest.xml

Po napisaniu klas niestandardowych należy je uwzględnić w AndroidManifest.xml , aby zaczęły obowiązywać. Upewnij się, że manifest zawiera narzędzia scalania, deklarując odpowiedni atrybut wewnątrz tagu <manifest> w następujący 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 deklaruje domyślną ListenerService FCM. Ten manifest jest zwykle łączony z manifestem specyficznym dla projektu, w ten sposób może działać ListenerService . Tę ListenerService należy zastąpić niestandardową usługą słuchacza. Osiąga się to poprzez usunięcie domyślnej ListenerService i dodanie usługi niestandardowej, co można zrobić za pomocą następujących wierszy pliku AndroidManifest.xml projektów:

<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 Firebase C++ SDK (od 7.1.0) korzystają z JobIntentService , która 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>

Zapobiegaj automatycznej inicjalizacji

FCM generuje token rejestracyjny do kierowania na urządzenia. Po wygenerowaniu tokenu biblioteka przesyła identyfikator i dane konfiguracyjne do Firebase. Jeśli chcesz uzyskać wyraźną zgodę przed użyciem tokena, możesz uniemożliwić generowanie w czasie konfiguracji, wyłączając FCM (oraz w systemie Android Analytics). Aby to zrobić, dodaj wartość metadanych do pliku Info.plist (nie do 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>

Szybki

FirebaseMessagingAutoInitEnabled = NO

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

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

Po ustawieniu ta wartość będzie obowiązywać po ponownym uruchomieniu aplikacji.

FCM umożliwia wysyłanie wiadomości zawierających głęboki link do Twojej aplikacji. Aby otrzymywać wiadomości zawierające precyzyjny link, musisz dodać nowy filtr intencji do działania obsługującego precyzyjne linki dla Twojej aplikacji. Filtr intencji powinien wychwytywać głębokie linki Twojej domeny. Jeśli Twoje wiadomości nie zawierają głębokiego 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żliwe jest również określenie symbolu wieloznacznego, aby filtr intencji był bardziej elastyczny. Na 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 dotkną powiadomienia zawierającego link do określonego schematu i hosta, Twoja aplikacja rozpocznie działanie z tym filtrem intencji, aby obsłużyć link.

Następne kroki

Po skonfigurowaniu aplikacji klienckiej możesz wysyłać wiadomości podrzędne i tematyczne za pomocą Firebase. Aby dowiedzieć się więcej, zapoznaj się z tą funkcją zademonstrowaną w przykładzie szybkiego startu , który możesz pobrać, uruchomić i przejrzeć.

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

Pamiętaj, że aby móc korzystać z tych funkcji, będziesz potrzebować implementacji serwera .