Konfigurowanie aplikacji klienckiej Komunikacja w chmurze Firebase na urządzeniu z Androidem

FCM Klienci wymagają urządzeń z Androidem 5.0 lub nowszym z zainstalowaną aplikacją Sklep Play lub emulatora z Androidem 5.0 z interfejsami API Google. Pamiętaj, że nie musisz wdrażać aplikacji na Androida w Sklepie Google Play.

Konfigurowanie pakietu SDK

W tej sekcji znajdziesz czynności, które możesz wykonać, jeśli masz już w swojej aplikacji włączone inne funkcje Firebase. Dodaj Firebase do projektu na Androida, jeśli jeszcze tego nie zrobisz.

Edytowanie pliku manifestu aplikacji

Do pliku manifestu aplikacji dodaj te elementy:

  • Usługa rozszerzająca FirebaseMessagingService. Jest to wymagane, jeśli chcesz zarządzać wiadomościami w sposób inny niż poprzez otrzymywanie powiadomień w aplikacjach działających w tle. Aby otrzymywać powiadomienia w aplikacjach na pierwszym planie, odbierać dane, wysyłać wiadomości w dół łańcucha itp., 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>
    AndroidManifest.xml
  • (Opcjonalnie) W komponencie aplikacji są elementy metadanych pozwalające ustawić domyślną ikonę i kolor powiadomienia. Android używa tych wartości za każdym razem, gdy wiadomości przychodzące nie mają jawnie ustawionej ikony lub 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" />
    AndroidManifest.xml
  • (Opcjonalnie) Począwszy od Androida 8.0 (poziom interfejsu API 26) i wyżej obsługiwane są kanały powiadomień i zaleca się ich używanie. 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 przychodzące wiadomości nie będą miały jawnie ustawionego kanału powiadomień. Więcej informacji znajdziesz w artykule Zarządzanie kanałami powiadomień. 
    • <meta-data
    android:name="com.google.firebase.messaging.default_notification_channel_id"
    android:value="@string/default_notification_channel_id" />
    AndroidManifest.xml

Prośba o zgodę na wyświetlanie powiadomień w czasie działania aplikacji w Androidzie 13 i nowszych

Android 13 wprowadza nowe uprawnienie do wyświetlania powiadomień. Dotyczy to wszystkich aplikacji na Androidzie 13 lub nowszym, które używają powiadomień FCM.

Domyślnie pakiet SDK FCM (w wersji 23.0.6 lub nowszej) zawiera uprawnienie POST_NOTIFICATIONS zdefiniowane w pliku manifestu. Aplikacja musi też poprosić o wersję tego uprawnienia w czasie wykonywania za pomocą stałej android.permission.POST_NOTIFICATIONS. Twoja aplikacja nie będzie mogła wyświetlać powiadomień, dopóki użytkownik nie udzieli na to zgody.

Aby poprosić o nowe uprawnienia w czasie wykonywania:

Kotlin+KTX

// 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)
        }
    }
}
MainActivity.kt

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);
        }
    }
}
MainActivity.java

Należy pokazać użytkownikowi interfejs z wyjaśnieniem funkcji, które zostaną włączone, jeśli przyznają aplikacji uprawnienia do publikowania powiadomień. Interfejs powinien zawierać opcje akceptacji lub odrzucenia, takie jak 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ę, zezwól mu na kontynuowanie bez powiadomień.

Aby dowiedzieć się więcej o tym, kiedy aplikacja powinna poprosić użytkownika o przyznanie uprawnienia POST_NOTIFICATIONS, zapoznaj się z artykułem Uprawnienia dotyczące powiadomień w czasie działania.

Uprawnienia dotyczące powiadomień w przypadku aplikacji kierowanych na Androida 12L (poziom API 32) lub starszego

Przy pierwszym tworzeniu kanału powiadomień przez aplikację Android automatycznie prosi użytkownika o zgodę, o ile działa ona na pierwszym planie. Istnieją jednak ważne zastrzeżenia dotyczące czasu tworzenia kanału i prośb o uprawnienia:

  • Jeśli aplikacja utworzy pierwszy kanał powiadomień, gdy działa w tle (co pakiet SDK FCM robi po otrzymaniu powiadomienia FCM), Android nie pozwoli na wyświetlenie powiadomienia i nie poprosi użytkownika o uprawnienia do wyświetlania powiadomień, dopóki aplikacja nie zostanie otwarta ponownie. Oznacza to, że wszystkie powiadomienia otrzymane przed otwarciem aplikacji i wyrażeniem przez użytkownika zgody na dostęp do tych danych zostaną utracone.
  • Zdecydowanie zalecamy zaktualizowanie aplikacji na Androida 13 lub nowszego, aby móc korzystać z interfejsów API platformy do żądania uprawnień. Jeśli nie jest to możliwe, aplikacja powinna utworzyć kanały powiadomień przed wysłaniem powiadomień, aby wywołać okno z prośbą o dostęp do powiadomień i zadbać o to, aby żadne powiadomienia nie zostały utracone. Więcej informacji znajdziesz w artykule Sprawdzone metody dotyczące uprawnień do wysyłania powiadomień.

Opcjonalnie: usuń uprawnienie POST_NOTIFICATIONS

Domyślnie pakiet SDK FCM zawiera uprawnienie POST_NOTIFICATIONS. Jeśli Twoja aplikacja nie używa wiadomości powiadomień (FCM powiadomień, innego pakietu SDK lub bezpośrednio przez aplikację) i nie chcesz, aby aplikacja zawierała to uprawnienie, możesz je usunąć za pomocą elementu remove w pliku manifestu. Pamiętaj, że usunięcie tego uprawnienia spowoduje wyłączenie wszystkich powiadomień, a nie tylko tych o treściach FCM. Dodaj do pliku manifestu aplikacji te elementy:

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

Uzyskiwanie dostępu do tokena rejestracji urządzenia

Przy pierwszym uruchomieniu aplikacji pakiet SDK FCM generuje token rejestracji dla instancji aplikacji klienckiej. Jeśli chcesz kierować reklamy na pojedyncze urządzenia lub utworzyć grupy urządzeń, musisz uzyskać dostęp do tego tokena, rozszerzając zakres FirebaseMessagingService i zastępując onNewToken.

Z tej sekcji dowiesz się, jak pobrać token i monitorować jego zmiany. Ponieważ token może zostać zastąpiony po pierwszym uruchomieniu, zdecydowanie zalecamy pobranie najnowszego zaktualizowanego tokena rejestracji.

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

  • Aplikacja jest przywracana na nowym urządzeniu
  • Użytkownik odinstalowuje lub ponownie instaluje aplikację.
  • Użytkownik czyści dane aplikacji.

Pobierz bieżący token rejestracji

Aby pobrać bieżący token, wywołaj FirebaseMessaging.getInstance().getToken():

Kotlin+KTX

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

Funkcja zwracana onNewToken jest wywoływana za każdym razem, gdy generowany jest nowy token.

Kotlin+KTX

/**
 * 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)
}
MyFirebaseMessagingService.kt

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);
}
MyFirebaseMessagingService.java

Po uzyskaniu tokena możesz wysłać go na serwer aplikacji i zapisać przy użyciu wybranej metody.

Sprawdzanie Usług Google Play

Aplikacje korzystające z pakietu SDK Usług Google Play powinny zawsze sprawdzić na urządzeniu, czy jest dostępny zgodny plik APK Usług Google Play, zanim zaczną korzystać z ich funkcji. Zalecamy wykonanie tego w 2 miejscach: w metodzie onCreate() głównej aktywności i w metodzie onResume() tej aktywności. Sprawdzenie w onCreate() zapewnia, że aplikacji nie można użyć bez pomyślnego sprawdzenia. Sprawdzenie w onResume() zapewnia, że jeśli użytkownik wróci do uruchomionej aplikacji w inny sposób, np. za pomocą przycisku Wstecz, sprawdzenie zostanie przeprowadzone.

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

Zapobieganie automatycznej inicjalizacji

Gdy wygenerowany zostanie token rejestracji FCM, biblioteka prześle identyfikator i dane konfiguracji do Firebase. Jeśli chcesz zapobiec automatycznemu generowaniu tokenów, wyłącz zbieranie tokenów przez Analytics i automatyczne inicjowanie FCM (musisz wyłączyć obie te wartości), dodając do AndroidManifest.xml te wartości metadanych:

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

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

Kotlin+KTX

Firebase.messaging.isAutoInitEnabled = true
MainActivity.kt

Java

FirebaseMessaging.getInstance().setAutoInitEnabled(true);
MainActivity.java

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

setAnalyticsCollectionEnabled(true);

Po ustawieniu wartości te są zachowywane w przypadku ponownych uruchomień aplikacji.

Dalsze kroki

Po skonfigurowaniu aplikacji klienckiej możesz zacząć wysyłać kolejne wiadomości za pomocą edytora powiadomień. Ta funkcja jest demonstrowana w przykładowej aplikacji Szybki start, którą możesz pobrać, uruchomić i przeanalizować.

Aby dodać do aplikacji inne, bardziej zaawansowane funkcje, możesz zadeklarować filtr intencji i wdrażać aktywność, która będzie odpowiadać na przychodzące wiadomości. Szczegółowe informacje znajdziesz w poniższych przewodnikach dotyczących wysyłania wiadomości z serwera aplikacji:

Pamiętaj, że aby korzystać z tych funkcji, musisz mieć implementację serwera i protokoły serwera (HTTP lub XMPP) albo implementację Admin SDK.