Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Skonfiguruj aplikację kliencką Firebase Cloud Messaging na Androida

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Klienci FCM wymagają urządzeń z systemem Android 4.4 lub nowszym, na których jest również zainstalowana aplikacja Sklep Google Play lub emulator systemu Android 4.4 z interfejsami Google API. Pamiętaj, że nie jesteś ograniczony do wdrażania aplikacji na Androida za pośrednictwem Sklepu Google Play.

Skonfiguruj zestaw SDK

W tej sekcji opisano zadania, które mogłeś wykonać, jeśli w swojej aplikacji masz już włączone inne funkcje Firebase. Jeśli jeszcze tego nie zrobiłeś, dodaj Firebase do swojego projektu na Androida

Edytuj manifest aplikacji

Dodaj następujące elementy do manifestu swojej aplikacji:

  • Usługa, która rozszerza FirebaseMessagingService . Jest to wymagane, jeśli chcesz obsługiwać wiadomości poza otrzymywaniem powiadomień w aplikacjach w tle. Aby otrzymywać powiadomienia w aplikacjach pierwszoplanowych, odbierać dane, wysyłać wiadomości typu upstream itd., 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, aby ustawić domyślną ikonę i kolor powiadomienia. Android używa tych wartości zawsze, gdy wiadomości przychodzące nie ustawiają jawnie 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 wersji Android 8.0 (API poziom 26) i nowszych kanały powiadomień są obsługiwane i zalecane. FCM zapewnia 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; FCM użyje tej wartości za każdym razem, gdy wiadomości przychodzące nie ustawią jawnie kanału powiadomień. Aby dowiedzieć się więcej, zobacz Zarządzanie kanałami powiadomień .
  • <meta-data
        android:name="com.google.firebase.messaging.default_notification_channel_id"
        android:value="@string/default_notification_channel_id" />

Poproś o pozwolenie na powiadomienia w czasie wykonywania na Androidzie 13+

Android 13 wprowadza nowe uprawnienia do wyświetlania powiadomień w czasie wykonywania. Dotyczy to wszystkich aplikacji działających na Androidzie 13 lub nowszym, które korzystają z powiadomień FCM.

Domyślnie pakiet FCM SDK (wersja 23.0.6 lub nowsza) zawiera uprawnienie POST_NOTIFICATIONS zdefiniowane w manifeście. Jednak Twoja aplikacja będzie również musiała zażądać wersji tego uprawnienia w czasie wykonywania za pośrednictwem stałej android.permission.POST_NOTIFICATIONS . Twoja aplikacja nie będzie mogła wyświetlać powiadomień, dopóki użytkownik nie przyzna tego uprawnienia.

Aby poprosić o nowe uprawnienia wykonawcze:

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)
        }
    }
}

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

Ogólnie rzecz biorąc, należy wyświetlić interfejs użytkownika wyjaśniający użytkownikowi funkcje, które zostaną włączone, jeśli przyzna on aplikacji uprawnienia do publikowania powiadomień. Ten interfejs użytkownika powinien zapewniać użytkownikowi opcje wyrażenia zgody lub odrzucenia, takie jak przyciski OK i Nie, dziękuję . Jeśli użytkownik wybierze OK , bezpośrednio poproś o pozwolenie. Jeśli użytkownik wybierze opcję Nie, dziękuję , zezwól mu na kontynuowanie bez powiadomień.

Zobacz Uprawnienia środowiska uruchomieniowego powiadomień , aby uzyskać więcej najlepszych praktyk dotyczących tego, kiedy aplikacja powinna żądać od użytkownika uprawnienia POST_NOTIFICATIONS .

Uprawnienia do powiadomień dla aplikacji kierowanych na Androida 12L (poziom interfejsu API 32) lub niższy

Android automatycznie prosi użytkownika o pozwolenie, 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 próśb o pozwolenie:

  • Jeśli Twoja aplikacja utworzy swój pierwszy kanał powiadomień, gdy działa w tle (co robi pakiet FCM SDK po otrzymaniu powiadomienia FCM), Android nie zezwoli na wyświetlenie powiadomienia i nie poprosi użytkownika o pozwolenie na powiadomienie do następnego czas otwarcia aplikacji. Oznacza to, że wszelkie powiadomienia otrzymane przed otwarciem aplikacji i zaakceptowaniem pozwolenia przez użytkownika zostaną utracone .
  • Zdecydowanie zalecamy zaktualizowanie aplikacji do Androida 13+, aby móc korzystać z interfejsów API platformy i prosić o pozwolenie. Jeśli nie jest to możliwe, Twoja aplikacja powinna utworzyć kanały powiadomień przed wysłaniem jakichkolwiek powiadomień do aplikacji, aby wywołać okno dialogowe uprawnień do powiadomień i upewnić się, że żadne powiadomienia nie zostaną utracone. Zobacz najlepsze praktyki dotyczące uprawnień do powiadomień, aby uzyskać więcej informacji.

Opcjonalnie: usuń uprawnienie POST_NOTIFICATIONS

Domyślnie zestaw SDK FCM obejmuje uprawnienie POST_NOTIFICATIONS . Jeśli Twoja aplikacja nie korzysta z powiadomień (za pośrednictwem powiadomień FCM, innego pakietu SDK lub publikowanych bezpośrednio przez Twoją aplikację) i nie chcesz, aby Twoja aplikacja uwzględniała to uprawnienie, możesz ją usunąć za pomocą znacznika remove manifestu fuzji . Pamiętaj, że usunięcie tego uprawnienia uniemożliwia wyświetlanie wszystkich powiadomień, nie tylko powiadomień FCM. Dodaj następujące informacje do pliku manifestu aplikacji:

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

Uzyskaj dostęp do tokena rejestracji urządzenia

Podczas pierwszego uruchomienia aplikacji zestaw FCM SDK generuje token rejestracji dla instancji aplikacji klienckiej. Jeśli chcesz kierować reklamy na pojedyncze urządzenia lub tworzyć grupy urządzeń, musisz uzyskać dostęp do tego tokenu, rozszerzając FirebaseMessagingService i zastępując onNewToken .

W tej sekcji opisano, jak pobrać token i jak monitorować zmiany w tokenie. Ponieważ token może zostać obrócony po początkowym uruchomieniu, zdecydowanie zaleca się pobranie najnowszego zaktualizowanego tokenu rejestracji.

Token rejestracji może ulec zmianie, gdy:

  • Aplikacja zostanie przywrócona na nowym urządzeniu
  • Użytkownik odinstalowuje/ponownie instaluje aplikację
  • Użytkownik czyści dane aplikacji.

Pobierz bieżący token rejestracji

Gdy musisz 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();
        }
    });

Monitoruj generowanie tokenów

Wywołanie zwrotne onNewToken jest uruchamiane 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)
}

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 wysłać go na serwer aplikacji i przechowywać przy użyciu preferowanej metody.

Sprawdź usługi Google Play

Aplikacje korzystające z pakietu SDK usług Google Play powinny zawsze sprawdzać urządzenie pod kątem kompatybilnego pakietu APK usług Google Play przed uzyskaniem dostępu do funkcji usług Google Play. Zaleca się, aby zrobić to w dwóch miejscach: w metodzie onCreate() głównego działania oraz w jego onResume() . onCreate() zapewnia, że ​​aplikacja nie może być używana bez pomyślnego sprawdzenia. Sprawdzenie w onResume() zapewnia, że ​​jeśli użytkownik powróci do działającej aplikacji w inny sposób, na przykład za pomocą przycisku Wstecz, sprawdzenie jest nadal wykonywane.

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

Zapobiegaj automatycznej inicjalizacji

Gdy generowany jest token rejestracji FCM, biblioteka przesyła identyfikator i dane konfiguracyjne do Firebase. Jeśli wolisz zapobiegać automatycznemu generowaniu tokenów, wyłącz gromadzenie Analytics i automatyczną inicjalizację FCM (musisz wyłączyć obie te wartości), dodając te wartości metadanych do 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" />

Aby ponownie włączyć automatyczne inicjowanie FCM, wykonaj wywołanie w czasie wykonywania:

Kotlin+KTX

Firebase.messaging.isAutoInitEnabled = true

Java

FirebaseMessaging.getInstance().setAutoInitEnabled(true);

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

setAnalyticsCollectionEnabled(true);

Te wartości są zachowywane po ponownym uruchomieniu aplikacji.

Następne kroki

Po skonfigurowaniu aplikacji klienckiej możesz rozpocząć wysyłanie komunikatów podrzędnych za pomocą narzędzia Notifications Composer . Ta funkcja jest zademonstrowana w przykładzie szybkiego startu , który można pobrać, uruchomić i przejrzeć.

Aby dodać inne, bardziej zaawansowane zachowanie do swojej aplikacji, możesz zadeklarować filtr intencji i zaimplementować działanie odpowiadające na przychodzące wiadomości. Aby uzyskać szczegółowe informacje, zapoznaj się z przewodnikami dotyczącymi wysyłania wiadomości z serwera aplikacji:

Pamiętaj, że aby skorzystać z tych funkcji, potrzebujesz implementacji serwera i protokołów serwera (HTTP lub XMPP) lub implementacji pakietu Admin SDK .