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

Klienty FCM wymagają urządzeń z Androidem 4.4 lub z zainstalowaną aplikacją Sklep Google Play lub emulatorem, z Androidem 4.4 i interfejsami API Google. Pamiętaj, że nie tylko wdrażanie Twoich aplikacji na Androida Sklepu Google Play.

Konfigurowanie pakietu SDK

Ta sekcja obejmuje zadania, które mogły zostać wykonane, jeśli zostały już włączone z innymi funkcjami Firebase w przypadku Twojej aplikacji. Dodaj Firebase do swojego projektu na Androida, chyba że masz to już za sobą.

Edytuj plik manifestu aplikacji

Do pliku manifestu aplikacji dodaj te elementy:

  • Usługa, która obejmuje FirebaseMessagingService. Jest to wymagane, jeśli chcą obsługiwać wiadomości poza otrzymywaniem powiadomień z aplikacji w tle. Aby otrzymywać powiadomienia w aplikacjach działających na pierwszym planie, aby otrzymywać aby wysyłać wiadomości nadrzędne itd., musisz rozszerzyć ten posprzedażna.
    • <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 służące do ustawienia powiadomienia domyślnego ikonę i kolor. Android używa tych wartości zawsze, gdy przychodzą wiadomości nie mają wyraźnie określonej 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) Od Androida 8.0 (poziom interfejsu API 26) lub nowszego kanały powiadomień są obsługiwane i zalecane. FCM udostępnia domyślną wartość kanału powiadomień z podstawowymi ustawieniami. Jeśli wolisz utwórz kanał domyślny i użyj go, ustaw default_notification_channel_id na identyfikator obiektu kanału powiadomień jak pokazano na ilustracji; FCM będzie tego używać wartość za każdym razem, gdy wiadomości przychodzące nie ustawiają powiadomienia wprost. kanał. Więcej informacji: Zarządzaj 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 uprawnienia w czasie działania aplikacji na urządzeniu z Androidem 13 lub nowszym

Android 13 wprowadza nowe uprawnienia w czasie działania dotyczące wyświetlania powiadomień. Ten dotyczy wszystkich aplikacji na Androidzie 13 lub nowszym, które używają FCM powiadomienia.

Domyślnie pakiet SDK FCM (w wersji 23.0.6 lub nowszej) zawiera: POST_NOTIFICATIONS. uprawnienia zdefiniowane w pliku manifestu. Aplikacja będzie jednak musiała również poprosić o wersję środowiska wykonawczego tego za pomocą stałej funkcji android.permission.POST_NOTIFICATIONS. Aplikacja nie będzie mogła pokazywać powiadomień do użytkownik przyznał to uprawnienie.

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

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

Powinien wyświetlać się interfejs wyjaśniający użytkownikowi funkcje, które zostaną włączone po przyznaniu uprawnień aby publikować powiadomienia. Interfejs ten powinien zawierać opcje zaakceptować lub odrzucić, na przykład OK i Nie, dziękuję; przyciskami. Jeśli użytkownik wybierze OK, poproś bezpośrednio o uprawnienie. Jeśli użytkownik wybierze Nie, dziękuję, zezwól na użytkownik może kontynuować bez powiadomień.

Zapoznaj się z sekcją Uprawnienia w czasie działania powiadomień , by poznać więcej sprawdzonych metod dotyczących tego, kiedy aplikacja powinna wysyłać żądania Uprawnienie POST_NOTIFICATIONS przyznane przez użytkownika.

Uprawnienia do wyświetlania powiadomień w aplikacjach kierowanych na Androida 12L (poziom API 32) lub niższy

Android automatycznie prosi użytkownika o pozwolenie przy pierwszym uruchomieniu aplikacji tworzy kanał powiadomień, o ile aplikacja działa na pierwszym planie. Istnieją jednak pewne zastrzeżenia dotyczące czasu utworzenia kanału. i prośby o uprawnienia:

  • Jeśli aplikacja utworzy swój pierwszy kanał powiadomień w trakcie działania w tle (z którego korzysta pakiet SDK FCM po otrzymaniu żądania FCM), Android nie zezwoli na powiadomienie wyświetlany i nie będzie pytać użytkownika o zgodę na wyświetlanie powiadomień, przy następnym uruchomieniu aplikacji. Oznacza to, że wszystkie otrzymane powiadomienia przed otwarciem aplikacji i zaakceptowaniem przez użytkownika uprawnień.
  • Zdecydowanie zalecamy zaktualizowanie aplikacji tak, aby była kierowana na Androida 13 lub nowszego użyć interfejsów API tej platformy, aby poprosić o odpowiednie uprawnienia. Jeśli tak nie jest aplikacja powinna utworzyć kanały powiadomień przed wysłaniem powiadomienia do aplikacji w celu aktywowania zgody na wyświetlanie powiadomień i sprawdź, czy nie zostaną utracone żadne powiadomienia. Zobacz sprawdzone metody dotyczące uzyskiwania zgody na powiadomienia .

Opcjonalnie: usuń uprawnienie POST_NOTIFICATIONS

Domyślnie pakiet SDK FCM zawiera uprawnienie POST_NOTIFICATIONS. Jeśli aplikacja nie korzysta z powiadomień (za pośrednictwem FCM) powiadomień, poprzez inny pakiet SDK lub bezpośrednio przez aplikację) oraz Jeśli nie chcesz, aby aplikacja miała te uprawnienia, możesz je usunąć za pomocą pokaż fuzji Znacznik remove. Pamiętaj, że usunięcie tego uprawnienia uniemożliwi wyświetlanie wszystkich powiadomień, a nie tylko powiadomień z FCM. Dodaj następujące elementy do plik manifestu aplikacji:

<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 rejestrację dla instancji aplikacji klienckiej. Jeśli chcesz kierować reklamy na pojedyncze urządzenia grup urządzeń, musisz uzyskać dostęp do tego tokena, rozszerzając FirebaseMessagingService z zastąpieniem onNewToken.

W tej sekcji dowiesz się, jak pobrać token i jak monitorować zmiany. do tokena. Ponieważ token może zostać poddany rotacji po początkowej uruchamiania, zdecydowanie zalecamy pobranie najnowszej zaktualizowanej rejestracji token.

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

  • Aplikacja zostanie przywrócona 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

Wywołanie zwrotne onNewToken jest uruchamiane po każdym wygenerowaniu nowego tokena.

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 go wysłać na swój serwer aplikacji i w sklepie za pomocą preferowanej metody.

Sprawdź, czy są dostępne Usługi Google Play

Aplikacje korzystające z pakietu SDK usług Google Play należy zawsze sprawdzić, czy na urządzeniu jest zgodny plik APK Usług Google Play dostęp do funkcji Usług Google Play. Zalecane jest wykonanie tej czynności w w dwóch miejscach: w metodzie onCreate() głównej aktywności oraz w jej Metoda onResume(). Dzięki sprawdzeniu onCreate() ma pewność, że aplikacja nie można użyć bez pomyślnego sprawdzenia. Dzięki sprawdzeniu w onResume() mamy pewność, że jeśli użytkownik wróci do uruchomionej aplikacji w inny sposób, np. przycisk Wstecz, sprawdza mimo to.

Jeśli urządzenie nie ma zgodnej wersji Usług Google Play, aplikacja może zadzwonić GoogleApiAvailability.makeGooglePlayServicesAvailable() , aby umożliwić użytkownikom pobieranie Usług Google Play ze Sklepu Play.

Zapobiegaj automatycznemu inicjowaniu

Po wygenerowaniu tokena rejestracji FCM biblioteka przesyła identyfikatora i danych konfiguracji, Firebase. Jeśli wolisz zapobiec automatycznemu generowaniu tokenów, wyłącz zbieranie danych przez Analytics i Automatyczne inicjowanie FCM (musisz wyłączyć obie), 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ć automatyczne inicjowanie FCM, wywołaj w czasie działania:

Kotlin KTX

Firebase.messaging.isAutoInitEnabled = true
MainActivity.kt

Java

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

Aby ponownie włączyć zbieranie danych przez Analytics, wywołaj funkcję 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 wiadomości wysyłane do kolejnych za pomocą funkcji Edytor powiadomień. Ta funkcja jest omówiono w krótkim wprowadzeniu, który można pobrać, uruchomić i sprawdzić.

Aby dodać do aplikacji inne, bardziej zaawansowane zachowania, może zadeklarować filtr intencji i zaimplementować działanie w odpowiedzi na przychodzące wiadomości. Szczegółowe informacje znajdziesz w przewodnikach dotyczących wysyłania wiadomości z serwera aplikacji:

Pamiętaj który pozwala wykorzystać tych funkcji wymaga implementacji serwera i prokotole serwera (HTTP lub XMPP) lub wdrożenia pakietu Admin SDK.