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

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

Konfigurowanie pakietu SDK

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

Edytowanie pliku manifestu aplikacji

Dodaj do pliku manifestu aplikacji te elementy:

  • Usługa, która rozszerza FirebaseMessagingService. Jest to wymagane, jeśli chcesz wykonywać inne działania związane z obsługą wiadomości niż tylko otrzymywanie powiadomień z aplikacji działających w tle. Aby otrzymywać powiadomienia w aplikacjach działających na pierwszym planie, otrzymywać ładunek danych 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 elementy metadanych do ustawiania domyślnej ikony i koloru powiadomienia. Android używa tych wartości, gdy w przychodzących wiadomościach nie określono wyraźnie 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" />
    AndroidManifest.xml
  • (Opcjonalnie) W przypadku Androida w wersji 8.0 (interfejs API na poziomie 26) i nowszych 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 poniżej. FCM będzie używać tej wartości, gdy przychodzące wiadomości nie będą wyraźnie ustawiać 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

Żądanie uprawnień do powiadomień w czasie działania w Androidzie 13 lub nowszym

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

Domyślnie pakiet SDK FCM (w wersji 23.0.6 lub nowszej) zawiera uprawnienie POST_NOTIFICATIONS zdefiniowane w manifeście. Aplikacja musi jednak też prosić o wersję tego uprawnienia w czasie działania za pomocą 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 środowiska wykonawczego:

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

Zazwyczaj należy wyświetlać interfejs, który wyjaśnia użytkownikowi funkcje, które zostaną włączone, jeśli przyzna on aplikacji uprawnienia do wysyłania powiadomień. Interfejs użytkownika powinien zawierać opcje zgody lub odmowy, takie jak przyciski OK i Nie, dziękuję. Jeśli użytkownik kliknie OK, bezpośrednio poproś o uprawnienia. Jeśli użytkownik wybierze Nie, dziękuję, zezwól mu na kontynuowanie bez powiadomień.

Więcej sprawdzonych metod dotyczących tego, kiedy aplikacja powinna prosić użytkownika o przyznanie uprawnienia POST_NOTIFICATIONS, znajdziesz w artykule Uprawnienia w czasie działania dotyczące powiadomień.

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

Android automatycznie prosi użytkownika o zezwolenie przy pierwszym utworzeniu przez aplikację kanału powiadomień, o ile aplikacja jest 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 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 uprawnienia do powiadomień, dopóki aplikacja nie zostanie ponownie otwarta. Oznacza to, że wszystkie powiadomienia otrzymane przed otwarciem aplikacji i zaakceptowaniem przez użytkownika uprawnień zostaną utracone.
  • Zdecydowanie zalecamy zaktualizowanie aplikacji, aby była kierowana na Androida 13 lub nowszego. Dzięki temu będziesz mieć możliwość korzystania z interfejsów API platformy do wysyłania próśb o uprawnienia. Jeśli to niemożliwe, aplikacja powinna utworzyć kanały powiadomień przed wysłaniem do niej jakichkolwiek powiadomień, aby wywołać okno dialogowe z prośbą o zezwolenie na powiadomienia i zapewnić, że żadne powiadomienia nie zostaną utracone. Więcej informacji znajdziesz w sprawdzonych metodach dotyczących uprawnień do wysyłania powiadomień.

Opcjonalnie: usuń uprawnienie POST_NOTIFICATIONS

Domyślnie pakiet SDK FCM zawiera uprawnienie POST_NOTIFICATIONS. Jeśli Twoja aplikacja nie korzysta z wiadomości z powiadomieniami (ani za pomocą powiadomień, ani za pomocą innego pakietu SDK, ani bezpośrednio przez aplikację) i nie chcesz, aby zawierała to uprawnienie, możesz je usunąć za pomocą znacznika remove narzędzia do łączenia plików manifestu.FCM Pamiętaj, że usunięcie tego uprawnienia uniemożliwia wyświetlanie wszystkich powiadomień, a nie tylko powiadomień 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 rejestracyjny dla instancji aplikacji klienckiej. Jeśli chcesz kierować reklamy na pojedyncze urządzenia lub tworzyć grupy urządzeń, musisz uzyskać dostęp do tego tokena, rozszerzając FirebaseMessagingService i zastępując onNewToken.

W tej sekcji dowiesz się, jak pobrać token i monitorować zmiany w nim. Token może zostać zmieniony po początkowym uruchomieniu, dlatego zdecydowanie zalecamy pobranie najnowszego zaktualizowanego tokena rejestracji.

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

  • Aplikacja zostanie przywrócona na nowym urządzeniu.
  • Użytkownik odinstaluje lub ponownie zainstaluje aplikację
  • Użytkownik czyści dane aplikacji.

Pobieranie bieżącego tokena rejestracji

Aby 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)
}
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 go wysłać na serwer aplikacji i zapisać go wybraną metodą.

Sprawdzanie, czy masz Usługi Google Play

Aplikacje korzystające z pakietu SDK Usług Play powinny zawsze sprawdzać, czy na urządzeniu jest zainstalowany zgodny pakiet APK Usług Google Play, zanim uzyskają dostęp do funkcji Usług Google Play. Zalecamy to zrobić w 2 miejscach: w metodzie onCreate() głównej aktywności i w jej metodzie onResume(). Sprawdzanie onCreate() zapewnia, że aplikacja nie może być używana 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 nadal będzie wykonywane.

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 generowany jest FCMtoken rejestracji, biblioteka przesyła identyfikator i dane konfiguracyjne do Firebase. Jeśli wolisz zapobiegać automatycznemu generowaniu tokenów, wyłącz zbieranie danych przez Analytics i automatyczną inicjację 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" />
AndroidManifest.xml

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

Kotlin

Firebase.messaging.isAutoInitEnabled = true
MainActivity.kt

Java

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

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

setAnalyticsCollectionEnabled(true);

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

Dalsze kroki

Po skonfigurowaniu aplikacji klienckiej możesz zacząć wysyłać wiadomości do urządzenia za pomocą kompozytora powiadomień. Ta funkcja jest przedstawiona w przykładzie szybkiego startu, który możesz pobrać, uruchomić i sprawdzić.

Aby dodać do aplikacji inne, bardziej zaawansowane funkcje, możesz zadeklarować filtr intencji i wdrożyć aktywność, która będzie odpowiadać na przychodzące wiadomości. Więcej informacji znajdziesz w 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ę pakietu Admin SDK.