Wprowadzenie do Komunikacji w chmurze Firebase w aplikacjach na Androida

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


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

Klienci FCM wymagają urządzeń z Androidem 7.0 lub nowszym, na których zainstalowana jest aplikacja Sklep Google Play, lub emulatora z Androidem 7.0 i interfejsami API Google. Pamiętaj, że nie musisz wdrażać aplikacji na Androida tylko przez Sklep Google Play.

Konfigurowanie pakietu SDK

Dodaj Firebase do projektu aplikacji na Androida, jeśli nie korzystasz w nim jeszcze z tej usługi.

Aby zapewnić optymalne działanie usługi FCM, zdecydowanie zalecamy włączenie Google Analytics w projekcie. Google Analytics jest wymagany w przypadku raportowania dostarczania wiadomości w FCM.

Edytowanie pliku manifestu aplikacji

Dodaj do pliku manifestu aplikacji te elementy:

  • Usługa, która rozszerza FirebaseMessagingService. Jest to wymagane, jeśli chcesz wykonywać jakiekolwiek operacje na wiadomościach poza otrzymywaniem powiadomień w aplikacjach działających w tle. Aby otrzymywać powiadomienia w aplikacjach na pierwszym planie, ładunek danych i inne elementy, musisz rozszerzyć tę usługę.
    • <service
    android:name=".java.MyFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>
  • (Opcjonalnie) W komponencie aplikacji elementy metadanych do ustawienia domyślnej ikony i koloru powiadomienia. Android używa tych wartości, gdy wiadomości przychodzące nie mają wyraźnie ustawionej ikony ani koloru.
    • <!-- Set custom default icon. This is used when no icon is set for incoming notification messages.
     See README(https://goo.gl/l4GJaQ) for more. -->
<meta-data
    android:name="com.google.firebase.messaging.default_notification_icon"
    android:resource="@drawable/ic_stat_ic_notification" />
<!-- Set color used with incoming notification messages. This is used when no color is set for the incoming
     notification message. See README(https://goo.gl/6BKBk7) for more. -->
<meta-data
    android:name="com.google.firebase.messaging.default_notification_color"
    android:resource="@color/colorAccent" />
  • (Opcjonalnie) Od Androida 8.0 (poziom interfejsu API 26) obsługiwane i zalecane są kanały powiadomień. FCM udostępnia domyślny kanał powiadomień z podstawowymi ustawieniami. Jeśli wolisz utworzyć i używać własnego kanału domyślnego, ustaw default_notification_channel_id na identyfikator obiektu kanału powiadomień, jak pokazano na ilustracji. FCM będzie używać tej wartości, gdy wiadomości przychodzące nie będą miały wyraźnie ustawionego kanału powiadomień. Więcej informacji znajdziesz w artykule o zarządzaniu kanałami powiadomień. 
    • <meta-data
    android:name="com.google.firebase.messaging.default_notification_channel_id"
    android:value="@string/default_notification_channel_id" />

Prośba o zgodę na wyświetlanie powiadomień w czasie działania na Androidzie 13 lub nowszym

Android 13 wprowadza nowe uprawnienia w czasie działania aplikacji dotyczące wyświetlania powiadomień. Dotyczy to wszystkich aplikacji na Androida 13 lub nowszego, które korzystają z powiadomień FCM.

Domyślnie pakiet SDK FCM (w wersji 23.0.6 lub nowszej) zawiera uprawnienie POST_NOTIFICATIONS zdefiniowane w pliku manifestu. Aplikacja musi jednak również poprosić o wersję tego uprawnienia w czasie działania, używając stałej android.permission.POST_NOTIFICATIONS. Aplikacja nie będzie mogła wyświetlać powiadomień, dopóki użytkownik nie przyzna jej tego uprawnienia.

Aby poprosić o nowe uprawnienia w czasie działania:

Kotlin

// Declare the launcher at the top of your Activity/Fragment:
private val requestPermissionLauncher = registerForActivityResult(
    ActivityResultContracts.RequestPermission(),
) { isGranted: Boolean ->
    if (isGranted) {
        // FCM SDK (and your app) can post notifications.
    } else {
        // TODO: Inform user that that your app will not show notifications.
    }
}

private fun askNotificationPermission() {
    // This is only necessary for API level >= 33 (TIRAMISU)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) ==
            PackageManager.PERMISSION_GRANTED
        ) {
            // FCM SDK (and your app) can post notifications.
        } else if (shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS)) {
            // TODO: display an educational UI explaining to the user the features that will be enabled
            //       by them granting the POST_NOTIFICATION permission. This UI should provide the user
            //       "OK" and "No thanks" buttons. If the user selects "OK," directly request the permission.
            //       If the user selects "No thanks," allow the user to continue without notifications.
        } else {
            // Directly ask for the permission
            requestPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
        }
    }
}

Java

// Declare the launcher at the top of your Activity/Fragment:
private final ActivityResultLauncher<String> requestPermissionLauncher =
        registerForActivityResult(new ActivityResultContracts.RequestPermission(), isGranted -> {
            if (isGranted) {
                // FCM SDK (and your app) can post notifications.
            } else {
                // TODO: Inform user that that your app will not show notifications.
            }
        });

private void askNotificationPermission() {
    // This is only necessary for API level >= 33 (TIRAMISU)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS) ==
                PackageManager.PERMISSION_GRANTED) {
            // FCM SDK (and your app) can post notifications.
        } else if (shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS)) {
            // TODO: display an educational UI explaining to the user the features that will be enabled
            //       by them granting the POST_NOTIFICATION permission. This UI should provide the user
            //       "OK" and "No thanks" buttons. If the user selects "OK," directly request the permission.
            //       If the user selects "No thanks," allow the user to continue without notifications.
        } else {
            // Directly ask for the permission
            requestPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS);
        }
    }
}

Zasadniczo należy wyświetlić interfejs wyjaśniający użytkownikowi funkcje, które zostaną włączone, jeśli przyzna on aplikacji uprawnienia do wysyłania powiadomień. Interfejs powinien zawierać opcje umożliwiające użytkownikowi wyrażenie zgody lub odmowę, np. przyciski OK i Nie, dziękuję. Jeśli użytkownik kliknie OK, poproś bezpośrednio o uprawnienia. Jeśli użytkownik wybierze Nie, dziękuję, pozwól mu kontynuować bez powiadomień.

Więcej sprawdzonych metod dotyczących tego, kiedy aplikacja powinna prosić użytkownika o uprawnienie POST_NOTIFICATIONS, znajdziesz w artykule o uprawnieniach do powiadomień w czasie działania aplikacji.

Zgoda na wyświetlanie powiadomień w aplikacjach kierowanych na Androida 12L (poziom API 32) lub starszego

Android automatycznie prosi użytkownika o zgodę, gdy aplikacja po raz pierwszy tworzy kanał powiadomień, o ile aplikacja działa na pierwszym planie. Istnieją jednak ważne zastrzeżenia dotyczące czasu tworzenia kanału i przesyłania próśb o uprawnienia:

  • Jeśli aplikacja utworzy swój pierwszy kanał powiadomień, gdy działa w tle, co robi pakiet SDK FCM po otrzymaniu powiadomienia FCM, Android nie zezwoli na wyświetlenie powiadomienia i nie poprosi użytkownika o zgodę na wyświetlanie powiadomień, dopóki aplikacja nie zostanie ponownie otwarta. Oznacza to, że wszystkie powiadomienia otrzymane przed otwarciem aplikacji i zaakceptowaniem uprawnień przez użytkownika zostaną utracone.
  • Zdecydowanie zalecamy zaktualizowanie aplikacji, aby była kierowana na Androida 13 lub nowszego, co pozwoli korzystać z interfejsów API platformy do prośby o uprawnienia. Jeśli nie jest to możliwe, aplikacja powinna utworzyć kanały powiadomień, zanim wyślesz do niej jakiekolwiek powiadomienia, aby wywołać okno zgody na wyświetlanie powiadomień i upewnić się, że żadne powiadomienia nie zostaną utracone. Więcej informacji znajdziesz w sprawdzonych metodach dotyczących zgody na wyświetlanie powiadomień.

Opcjonalnie: usuń uprawnienie POST_NOTIFICATIONS

Domyślnie pakiet SDK FCM zawiera uprawnienie POST_NOTIFICATIONS. Jeśli Twoja aplikacja nie używa powiadomień (ani przez FCM, ani przez inny pakiet SDK, ani bezpośrednio), a nie chcesz, aby zawierała uprawnienia, możesz je usunąć za pomocą znacznika remove narzędzia do scalania plików manifestu. Pamiętaj, że usunięcie tego uprawnienia uniemożliwi wyświetlanie wszystkich powiadomień, nie tylko tych z aplikacji FCM. Dodaj do pliku manifestu aplikacji te elementy:

<uses-permission android:name="android.permission.POST_NOTIFICATIONS" tools:node="remove"/>

Dostęp do identyfikatora instalacji Firebase

Przy pierwszym uruchomieniu aplikacji pakiet SDK FCM rejestruje instancję aplikacji w FCM i zwraca jej identyfikator. Jeśli chcesz kierować reklamy na poszczególne instancje aplikacji, musisz uzyskać dostęp do tego identyfikatora, rozszerzając FirebaseMessagingService i zastępując onRegistered(). Zalecamy pobranie najnowszego zaktualizowanego identyfikatora, ponieważ po pierwszym uruchomieniu może on ulec zmianie.

Włącz rejestrację za pomocą identyfikatora instalacji Firebase

Aby umożliwić rejestrowanie instancji aplikacji w usłudze FCM za pomocą identyfikatora instalacji Firebase (FID), dodaj do pliku AndroidManifest.xml tę flagę metadanych: 
<meta-data
    android:name="firebase_messaging_installation_id_enabled"
    android:value="true" />

Implementowanie wywołania zwrotnego onRegistered()

Instancje aplikacji są kierowane za pomocą identyfikatora instalacji Firebase (FID) po zarejestrowaniu w FCM. Aby pobrać identyfikator FID podczas rejestracji, zaimplementuj wywołanie zwrotne onRegistered(). Po zarejestrowaniu instancji aplikacji pakiet SDK FCM automatycznie monitoruje zmiany FID i wywołuje wywołanie zwrotne, gdy wykryje zmianę. Gdy automatyczna inicjalizacja jest włączona, pakiet SDK FCM automatycznie synchronizuje się z backendem FCM, aby zachować aktualność rejestracji, i wywołuje wywołanie zwrotne, aby upewnić się, że serwer aplikacji ma aktualny identyfikator. Aby zapobiec utracie identyfikatora FID lub jego dezaktualizacji, wysyłaj go do serwera aplikacji za każdym razem, gdy wywoływana jest ta funkcja.

Kotlin

  /**
   * There are three scenarios when `onRegistered` is called:
   * 1) Every time a manual `register()` call finishes successfully
   * 2) Whenever the FID is changed and the app is re-registered with FCM via the new FID.
   * 3) Automatically on app startup or routine sync when auto-initialization is enabled.
   * Under #2, there are three scenarios when the existing FID is changed:
   * A) App is restored to a new device
   * B) User uninstalls/reinstalls the app
   * C) User clears app data
   */
  override fun onRegistered(installationId: String) {
      Log.d(TAG, "Registered installation ID: $installationId")

      // Send the Firebase Installation ID to your app server.
      sendRegistrationToServer(installationId)
  }

Java

  /**
   * There are three scenarios when `onRegistered` is called:
   * 1) Every time a manual `register()` call finishes successfully
   * 2) Whenever the FID is changed and the app is re-registered with FCM via the new FID
   * 3) Automatically on app startup or routine sync when auto-initialization is enabled.
   * Under #2, there are three scenarios when the existing FID is changed:
   * A) App is restored to a new device
   * B) User uninstalls/reinstalls the app
   * C) User clears app data
   */
  @Override
  public void onRegistered(@NonNull String installationId) {
      Log.d(TAG, "Registered installation ID: " + installationId);

      // Send the Firebase Installation ID to your app server.
      sendRegistrationToServer(installationId);
  }

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

Jeśli musisz wyłączyć automatyczną inicjalizację, pakiet SDK FCM nie będzie automatycznie synchronizować ani wywoływać wywołania zwrotnego onRegistered() podczas uruchamiania. Zdecydowanie zalecamy ponowne włączenie automatycznej inicjalizacji po przyznaniu zgody na wyświetlanie powiadomień. Więcej informacji znajdziesz w sekcji Ponowne włączanie automatycznej inicjalizacji.

Jeśli automatyczna inicjalizacja musi pozostać wyłączona, wywołaj FirebaseMessaging.getInstance().register() podczas uruchamiania aplikacji, aby aktywować rejestrację i dostarczanie identyfikatora FID za pomocą wywołania zwrotnego onRegistered(). Możesz wykonać to wywołanie w metodzie onCreate() głównego elementu Activity.

Kotlin

  // Trigger manual registration if auto-initialization is turned off.
  // Consider calling this every time the app starts to guarantee sync status.
  FirebaseMessaging.getInstance().register()
      .addOnCompleteListener(this) { task ->
        if (!task.isSuccessful()) {
          // Registration failed. Consider retrying the registration with exponential backoff.
          Log.w(TAG, "Failed to register with Firebase Cloud Messaging", task.exception)
        }
        // Success! The Firebase Installation ID can be used to target messages to this app
        // instance and will be delivered asynchronously to your `onRegistered()` callback.
      }

Java

  // Trigger manual registration if auto-initialization is turned off.
  // Consider calling this every time the app starts to guarantee sync status.
  FirebaseMessaging.getInstance().register()
      .addOnCompleteListener(task -> {
        if (!task.isSuccessful()) {
          // Registration failed. Consider retrying the registration with exponential backoff.
          Log.w(TAG, "Failed to register with Firebase Cloud Messaging", task.exception)
        }
        // Success! The Firebase Installation ID can be used to target messages to this app
        // instance and will be delivered asynchronously to your `onRegistered()` callback.
      });

Dostęp do tokena rejestracji FCM (wycofany)

Podczas pierwszego uruchomienia aplikacji pakiet SDK FCM generuje token rejestracji dla instancji aplikacji klienckiej. Jeśli chcesz kierować reklamy na pojedyncze instancje aplikacji lub tworzyć grupy urządzeń, musisz uzyskać dostęp do tego tokena, rozszerzając FirebaseMessagingService i zastępując onNewToken. Ponieważ token może zostać zmieniony po pierwszym uruchomieniu, zdecydowanie zalecamy pobranie najnowszego zaktualizowanego tokena rejestracji.

Token rejestracji może się zmienić, gdy:

  • aplikacja zostanie przywrócona na nowym urządzeniu,
  • Użytkownik odinstalowuje lub ponownie instaluje aplikację.
  • użytkownik wyczyści dane aplikacji;

Pobieranie bieżącego tokena rejestracji

Jeśli chcesz pobrać bieżący token, wywołaj FirebaseMessaging.getInstance().getToken():

Kotlin

FirebaseMessaging.getInstance().token.addOnCompleteListener(OnCompleteListener { task ->
    if (!task.isSuccessful) {
        Log.w(TAG, "Fetching FCM registration token failed", task.exception)
        return@OnCompleteListener
    }

    // Get new FCM registration token
    val token = task.result

    // Log and toast
    val msg = getString(R.string.msg_token_fmt, token)
    Log.d(TAG, msg)
    Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
})

Java

FirebaseMessaging.getInstance().getToken()
    .addOnCompleteListener(new OnCompleteListener<String>() {
        @Override
        public void onComplete(@NonNull Task<String> task) {
          if (!task.isSuccessful()) {
            Log.w(TAG, "Fetching FCM registration token failed", task.getException());
            return;
          }

          // Get new FCM registration token
          String token = task.getResult();

          // Log and toast
          String msg = getString(R.string.msg_token_fmt, token);
          Log.d(TAG, msg);
          Toast.makeText(MainActivity.this, msg, Toast.LENGTH_SHORT).show();
        }
    });

Monitorowanie generowania tokenów

Wywołanie zwrotne onNewToken jest uruchamiane za każdym razem, gdy generowany jest nowy token.

Kotlin

/**
 * Called if the FCM registration token is updated. This may occur if the security of
 * the previous token had been compromised. Note that this is called when the
 * FCM registration token is initially generated so this is where you would retrieve the token.
 */
override fun onNewToken(token: String) {
    Log.d(TAG, "Refreshed token: $token")

    // If you want to send messages to this application instance or
    // manage this apps subscriptions on the server side, send the
    // FCM registration token to your app server.
    sendRegistrationToServer(token)
}

Java

/**
 * There are two scenarios when onNewToken is called:
 * 1) When a new token is generated on initial app startup
 * 2) Whenever an existing token is changed
 * Under #2, there are three scenarios when the existing token is changed:
 * A) App is restored to a new device
 * B) User uninstalls/reinstalls the app
 * C) User clears app data
 */
@Override
public void onNewToken(@NonNull String token) {
    Log.d(TAG, "Refreshed token: " + token);

    // If you want to send messages to this application instance or
    // manage this apps subscriptions on the server side, send the
    // FCM registration token to your app server.
    sendRegistrationToServer(token);
}

Po uzyskaniu tokena możesz go wysłać na serwer aplikacji i zapisać, używając preferowanej metody.

Sprawdzanie usług Google Play

Aplikacje, które korzystają z pakietu SDK usług Google Play, powinny zawsze sprawdzać, czy na urządzeniu jest zgodny plik APK usług Google Play, zanim uzyskają dostęp do funkcji usług Google Play. Więcej informacji znajdziesz w artykule Konfigurowanie Usług Google Play. Zalecamy zrobienie tego w 2 miejscach: w metodzie onCreate() głównej aktywności i w jej metodzie onResume(). Sprawdzanie w onCreate() gwarantuje, że bez pomyślnej weryfikacji nie będzie można korzystać z aplikacji. Sprawdzanie w metodzie onResume() gwarantuje, że jeśli użytkownik wróci do uruchomionej aplikacji w inny sposób, np. za pomocą przycisku Wstecz, sprawdzanie nadal zostanie przeprowadzone.

Jeśli na urządzeniu nie ma zgodnej wersji Usług Google Play, aplikacja może wywołać metodę GoogleApiAvailability.makeGooglePlayServicesAvailable(), aby umożliwić użytkownikom pobranie Usług Google Play ze Sklepu Play.

Zapobieganie automatycznej inicjalizacji

Po wygenerowaniu rejestracji FCM biblioteka przesyła identyfikator i dane konfiguracji do Firebase. Jeśli chcesz zapobiec automatycznej rejestracji, wyłącz zbieranie danych przez Analytics i automatyczną inicjalizację FCM (musisz wyłączyć obie te funkcje), dodając te wartości metadanych do pliku AndroidManifest.xml:

<meta-data
    android:name="firebase_messaging_auto_init_enabled"
    android:value="false" />
<meta-data
    android:name="firebase_analytics_collection_enabled"
    android:value="false" />

Ponowne włączanie automatycznej inicjalizacji

Aby ponownie włączyć automatyczną inicjowanie FCM, wykonaj wywołanie w czasie działania:

Kotlin

Firebase.messaging.isAutoInitEnabled = true

Java

FirebaseMessaging.getInstance().setAutoInitEnabled(true);

Aby ponownie włączyć zbieranie danych Analytics, wywołaj metodę setAnalyticsCollectionEnabled() klasy FirebaseAnalytics. Przykład:

setAnalyticsCollectionEnabled(true);

Po ustawieniu te wartości są zachowywane po ponownym uruchomieniu aplikacji.

Wysyłanie powiadomienia

Aby sprawdzić, czy klient Androida jest prawidłowo skonfigurowany, możesz wysłać testową wiadomość z powiadomieniem, postępując zgodnie z tymi instrukcjami:

  1. Zainstaluj i uruchom aplikację na urządzeniu docelowym.

  2. Upewnij się, że aplikacja działa w tle na urządzeniu.

  3. W konsoli Firebase kliknij DevOps i zaangażowanie > Komunikacja.

  4. Utworzenie kampanii.

    • Jeśli to Twoja pierwsza wiadomość:

      1. Kliknij Utwórz pierwszą kampanię.

      2. Wybierz Powiadomienia Firebase i kliknij Utwórz.

    • Jeśli masz już utworzone kampanie:

      1. Na karcie Kampanie kliknij Nowa kampania.

      2. Kliknij Powiadomienia.

  5. Wpisz tekst wiadomości. Wszystkie pozostałe pola są opcjonalne.

  6. W panelu po prawej stronie wybierz Wyślij wiadomość testową.

  7. W polu Dodaj token rejestracji FCM wpisz token rejestracji uzyskany w poprzedniej sekcji tego przewodnika.

  8. Kliknij Przetestuj.

Urządzenie klienta, na którym aplikacja działa w tle, powinno otrzymać powiadomienie.

Aby uzyskać statystyki dotyczące dostarczania wiadomości do aplikacji, otwórz panel DevOps & Engagement (DevOps i zaangażowanie) > Messaging (Przesyłanie wiadomości) > Reports (Raporty) w konsoli Firebase. Ten panel rejestruje liczbę wiadomości wysłanych i otwartych na urządzeniach Apple i urządzeniach z Androidem, a także dane dotyczące „wyświetleń” (powiadomień wyświetlonych użytkownikom) w aplikacjach na Androida.

Dalsze kroki

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