Zarządzanie instalacjami Firebase

Usługa instalacji Firebase (FIS) udostępnia identyfikator instalacji Firebase (FID) każdej zainstalowanej instancji aplikacji Firebase. Identyfikator instalacji Firebase jest używany wewnętrznie przez te usługi Firebase:

Usługa Firebase Funkcja instalacji Firebase
Komunikacja w chmurze Firebase

Komunikacja w chmurze Firebase używa identyfikatorów instalacji Firebase do kierowania wiadomości na urządzenia.

Firebase Crashlytics

Firebase Crashlytics wykonuje rotację identyfikatora UUID instalacji Crashlytics na podstawie zmian identyfikatora instalacji Firebase instancji aplikacji. W przyszłości identyfikator instalacji może być używany do włączania funkcji, które ulepszają usługi zgłaszania awarii i zarządzania awariami.

Wysyłanie wiadomości w aplikacji Firebase

Funkcja Firebase Wysyłanie wiadomości w aplikacji używa identyfikatorów instalacji Firebase do kierowania wiadomości na urządzenia.

Monitorowanie wydajności Firebase

Monitorowanie wydajności wykorzystuje identyfikatory instalacji Firebase do obliczania liczby unikalnych instalacji Firebase, które korzystają z zasobów sieciowych. Dzięki temu wzorce dostępu są wystarczająco anonimowe. Korzysta też z identyfikatorów instalacji Firebase w połączeniu ze Zdalnej konfiguracji Firebase do zarządzania częstotliwością raportowania zdarzeń związanych z wydajnością.

Zdalna konfiguracja Firebase

Zdalna konfiguracja wykorzystuje identyfikatory instalacji Firebase do wyboru wartości konfiguracyjnych w celu zwrócenia się do urządzeń użytkowników.

Firebase ML

Dane logowania nazywane tokenami uwierzytelniania instalacji są używane przez ML Firebase do uwierzytelniania urządzeń podczas interakcji z instancjami aplikacji, na przykład do rozpowszechniania modeli programisty w instancjach aplikacji.

Miejsce na dane segmentacji użytkowników Firebase

Pamięć segmentacji użytkowników Firebase przechowuje identyfikatory instalacji Firebase oraz powiązane atrybuty i segmenty, aby dostarczać informacje kierowania do innych usług Firebase, które ich używają.

Zwykle usługi Firebase korzystają z usługi instalacji Firebase bez konieczności wykonywania przez deweloperów bezpośredniej interakcji z interfejsem FIS API. W niektórych przypadkach deweloperzy aplikacji mogą jednak chcieć bezpośrednio wywołać interfejs FIS API, na przykład:

  • Aby usunąć instalację Firebase i powiązane z nią dane.
  • Do pobierania identyfikatorów (identyfikatorów instalacji Firebase) w celu kierowania reklam na konkretne instalacje aplikacji.
  • Aby pobrać tokeny uwierzytelniania instalacji i uwierzytelnić instalacje Firebase.

Aby zacząć od bezpośredniego wywoływania interfejsu FIS API, dodaj SDK do swojej aplikacji.

Dodaj do aplikacji pakiet SDK instalacji Firebase

iOS+

  1. Dodaj zależność dotyczącą instalacji Firebase do pliku Podfile:
    pod 'FirebaseInstallations'
  2. Uruchom pod install i otwórz utworzony plik .xcworkspace.
  3. Zaimportuj moduł FirebaseCore do obiektu UIApplicationDelegate, a także wszystkie inne moduły Firebase używane przez przedstawiciela aplikacji. Aby na przykład użyć Cloud Firestore i Uwierzytelniania:

    Certyfikat SwiftUI

    import SwiftUI
    import FirebaseCore
    import FirebaseFirestore
    import FirebaseAuth
    // ...
          

    Swift

    import FirebaseCore
    import FirebaseFirestore
    import FirebaseAuth
    // ...
          

    Objective-C

    @import FirebaseCore;
    @import FirebaseFirestore;
    @import FirebaseAuth;
    // ...
          
  4. Skonfiguruj współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) przedstawiciela aplikacji:

    Certyfikat SwiftUI

    // Use Firebase library to configure APIs
    FirebaseApp.configure()

    Swift

    // Use Firebase library to configure APIs
    FirebaseApp.configure()

    Objective-C

    // Use Firebase library to configure APIs
    [FIRApp configure];
  5. Jeśli używasz SwiftUI, musisz utworzyć przedstawiciela aplikacji i dołączyć go do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Więcej informacji znajdziesz w instrukcjach SwiftUI.

    Certyfikat SwiftUI

    @main
    struct YourApp: App {
      // register app delegate for Firebase setup
      @UIApplicationDelegateAdaptor(AppDelegate.self) var delegate
    
      var body: some Scene {
        WindowGroup {
          NavigationView {
            ContentView()
          }
        }
      }
    }
          

Android

Dodaj zależność z pakietem SDK Androida do instalacji Firebase do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle):

implementation 'com.google.firebase:firebase-installations:18.0.0'

JavaScript

W zależności od sposobu hostowania aplikacji internetowej konfiguracja może być obsługiwana automatycznie lub może być konieczna aktualizacja obiektu konfiguracji Firebase.

Jeśli na przykład zależności dodano w pliku index.html, dodaj zależność do elementu <head>:

<script src="/__/firebase/10.12.3/firebase-installations.js"></script>

Flutter

  1. Aby zainstalować wtyczkę instalacyjną Firebase, uruchom to polecenie w katalogu głównym projektu Flutter:

    flutter pub add firebase_app_installations
    
  2. Przebuduj projekt:

    flutter run
    
  3. Zaimportuj wtyczkę instalacyjną Firebase:

    import 'package:firebase_app_installations/firebase_app_installations.dart';
    

Usuwanie instalacji Firebase

Dane powiązane z instalacją Firebase zasadniczo nie umożliwiają identyfikację osoby. Mimo to warto umożliwić użytkownikom zarządzanie tymi danymi i ich usuwanie.

Identyfikatory instalacji Firebase są różne w przypadku każdej instalacji każdej aplikacji. Różne aplikacje na tym samym urządzeniu mają różne identyfikatory instalacji Firebase. Identyfikatory instalacji Firebase identyfikują instalacje aplikacji i dane powiązane z tymi instalacjami.

Gdy usuniesz identyfikator instalacji, dane powiązane z tym identyfikatorem instalacji zostaną w ciągu 180 dni usunięte z systemów aktywnych i kopii zapasowych wszystkich usług Firebase, które korzystają z identyfikatorów instalacji Firebase do identyfikowania instalacji. Proces ten został szczegółowo opisany w oświadczeniu Google na temat usuwania i przechowywania danych.

Jeśli nie wyłączysz wszystkich usług generujących FID w swojej aplikacji, FIS utworzy nowy identyfikator w ciągu kilku dni. Firebase uznaje nowo utworzony identyfikator za nową instalację Firebase i w żaden sposób nie wiąże go z poprzednim identyfikatorem ani z poprzednimi danymi.

Usuń FID z wywołaniem interfejsu API klienta

Aby usunąć identyfikatory FID wygenerowane przez usługi Firebase, wywołaj odpowiednią metodę w pakiecie SDK instalacji Firebase:

Swift

do {
  try await Installations.installations().delete()
  print("Installation deleted");
} catch {
  print("Error deleting installation: \(error)")
}

Objective-C

[[FIRInstallations installations] deleteWithCompletion:^(NSError *error) {
   if (error != nil) {
     NSLog(@"Error deleting Installation %@", error);
     return;
   }
   NSLog(@"Installation deleted");
}];

Java

FirebaseInstallations.getInstance().delete()
        .addOnCompleteListener(new OnCompleteListener<Void>() {
    @Override
    public void onComplete(@NonNull Task<Void> task) {
        if (task.isSuccessful()) {
            Log.d("Installations", "Installation deleted");
        } else {
            Log.e("Installations", "Unable to delete Installation");
        }
    }
});

Kotlin+KTX

FirebaseInstallations.getInstance().delete().addOnCompleteListener { task ->
    if (task.isComplete) {
        Log.d("Installations", "Installation deleted")
    } else {
        Log.e("Installations", "Unable to delete Installation")
    }
}

JavaScript

await firebase.installations().delete();

Dart

await FirebaseInstallations.instance.delete();

Usuń FID z wywołaniem interfejsu API serwera

Aby usunąć FID z wywołaniem interfejsu API serwera, dodaj pakiet Firebase Admin SDK do swojego serwera.

Po dodaniu pakietu SDK usuń identyfikatory FID, wywołując funkcję usuwania w wybranym języku (uwaga: te metody z wyjątkiem Node.js odzwierciedlają nazwy identyfikatorów instancji. Wszystkie z nich jednak usuwają FID w przypadku wywołania dowolnego obecnego pakietu SDK Firebase.

Node.js

// An FIDsent from a client service SDK
const idToDelete = 'eyJhbGciOiJFUzI1N_iIs5';

admin.installations().deleteInstallation(idToDelete);

Java

// An FID sent from a client service SDK
String idToDelete = "eyJhbGciOiJFUzI1N_iIs5";

FirebaseInstanceId.getInstance().deleteInstanceIdAsync(idToDelete).get();

Python

  from firebase_admin import instance_id

  # An FID sent from a client service SDK
  id_to_delete = 'eyJhbGciOiJFUzI1N_iIs5'

  instance_id.delete_instance_id(id_to_delete)

Go

client, err := app.InstanceId(ctx)
if err != nil {
  log.Fatalln("error initializing client", err)
}

iidToDelete := "eyJhbGciOiJFUzI1N_iIs5"
if err := client.DeleteInstanceId(ctx, iidToDelete); err != nil {
  log.Fatalln("error deleting FID", err)
}

Gdy usuniesz identyfikator instalacji Firebase z wywołaniem interfejsu API serwera, usługi Firebase rozpoczną proces usuwania danych powiązanych z tym identyfikatorem instalacji, przestajemy przyjmować nowe dane dla tego identyfikatora w ciągu 1–2 dni. Potem powiadamiają aplikację kliencką, że identyfikator został usunięty. Dopóki Firebase nie powiadomi aplikacji klienta, niektóre jej usługi mogą nadal być kierowane na identyfikator. Na przykład instalacja Firebase może jeszcze przez kilka godzin otrzymywać powiadomienia FCM.

Jeśli chcesz usunąć bieżący identyfikator instalacji Firebase i od razu używać usług Firebase z nowym, niepowiązanym identyfikatorem, skorzystaj z interfejsu API klienta.

Pobieranie identyfikatorów klientów

Jeśli musisz określić konkretne instalacje swojej aplikacji, możesz to zrobić, pobierając identyfikator instalacji Firebase. Aby na przykład utworzyć segmenty instalacji aplikacji do importu przy użyciu BigQuery lub przeprowadzić testy podczas tworzenia funkcji Firebase Wysyłanie wiadomości w aplikacji, możesz zidentyfikować odpowiednie urządzenia i ustawić kierowanie na odpowiednie urządzenia za pomocą odpowiednich identyfikatorów instalacji Firebase.

Aby pobrać identyfikator instalacji Firebase:

Swift

do {
  let id = try await Installations.installations().installationID()
  print("Installation ID: \(id)")
} catch {
  print("Error fetching id: \(error)")
}

Objective-C

[[FIRInstallations installations] installationIDWithCompletion:^(NSString *identifier, NSError *error) {
  if (error != nil) {
    NSLog(@"Error fetching Installation ID %@", error);
    return;
  }
  NSLog(@"Installation ID: %@", identifier);
}];

Java

FirebaseInstallations.getInstance().getId()
        .addOnCompleteListener(new OnCompleteListener<String>() {
    @Override
    public void onComplete(@NonNull Task<String> task) {
        if (task.isSuccessful()) {
            Log.d("Installations", "Installation ID: " + task.getResult());
        } else {
            Log.e("Installations", "Unable to get Installation ID");
        }
    }
});

Kotlin+KTX

FirebaseInstallations.getInstance().id.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        Log.d("Installations", "Installation ID: " + task.result)
    } else {
        Log.e("Installations", "Unable to get Installation ID")
    }
}

JavaScript

const installationId = await firebase.installations().getId();
console.log(installationId);

Dart

String id = await FirebaseInstallations.instance.getId();

Pobieranie tokenów uwierzytelniania instalacji

Usługi Firebase mogą uwierzytelniać instalacje Firebase za pomocą tokenów uwierzytelniania pobranych z FIS. Na przykład przy projektowaniu testów A/B dla Zdalnej konfiguracji możesz uwierzytelnić docelowe urządzenie testowe przy użyciu tokena uwierzytelniania instalacji.

Token uwierzytelniania instalacji to krótkotrwały token okaziciela w formacie tokena sieciowego JSON (JWT) zawierający następujące informacje dotyczące instalacji:

  • Identyfikator instalacji Firebase
  • Powiązany projekt (projectNumber)
  • Identyfikator powiązanej aplikacji Firebase (appId)
  • datę ważności tokena;

Tokenu uwierzytelniania instalacji nie można unieważnić. Pozostanie on ważny do daty wygaśnięcia. Domyślny okres ważności tokena to jeden tydzień.

Aby pobrać token uwierzytelniania instalacji:

Swift

do {
  let result = try await Installations.installations()
    .authTokenForcingRefresh(true)
  print("Installation auth token: \(result.authToken)")
} catch {
  print("Error fetching token: \(error)")
}

Objective-C

[[FIRInstallations installations] authTokenForcingRefresh:true
                                               completion:^(FIRInstallationsAuthTokenResult *result, NSError *error) {
  if (error != nil) {
    NSLog(@"Error fetching Installation token %@", error);
    return;
  }
  NSLog(@"Installation auth token: %@", [result authToken]);
}];

Java

FirebaseInstallations.getInstance().getToken(/* forceRefresh */true)
        .addOnCompleteListener(new OnCompleteListener<InstallationTokenResult>() {
    @Override
    public void onComplete(@NonNull Task<InstallationTokenResult> task) {
        if (task.isSuccessful() && task.getResult() != null) {
            Log.d("Installations", "Installation auth token: " + task.getResult().getToken());
        } else {
            Log.e("Installations", "Unable to get Installation auth token");
        }
    }
});

Kotlin+KTX

val forceRefresh = true
FirebaseInstallations.getInstance().getToken(forceRefresh)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            Log.d("Installations", "Installation auth token: " + task.result?.token)
        } else {
            Log.e("Installations", "Unable to get Installation auth token")
        }
    }

JavaScript

const installationToken = await firebase.installations()
    .getToken(/* forceRefresh */ true);
console.log(installationToken);

Dart

String token = await FirebaseInstallations.instance.getToken();

Monitorowanie cyklu życia identyfikatora instalacji Firebase

Podczas normalnego działania aplikacji identyfikatory instalacji Firebase (FID) nie wymagają specjalnego monitorowania. Jednak aplikacje, które jawnie pobierają i używają identyfikatorów FID, powinny dodać logikę do monitorowania potencjalnego usunięcia lub rotacji identyfikatora. Oto kilka przypadków, w których elementy FID mogą zostać usunięte lub objęte rotacją:

  • Odinstalowanie lub ponowne zainstalowanie aplikacji, np. gdy użytkownik zainstaluje ją na nowym urządzeniu.
  • Użytkownik czyści pamięć podręczną aplikacji lub urządzenia.
  • Usuwanie FID jest wywoływane w backendzie z powodu braku aktywności aplikacji (obecnie próg wynosi 270 dni nieaktywności).

W takich przypadkach aplikacje otrzymują nowy identyfikator FID, który występuje w takich sytuacjach. Poza tym token uwierzytelniania instalacji powiązany z usuniętym identyfikatorem FID jest usuwany (niezależnie od jego dojrzałości) i zastępowany nowym tokenem uwierzytelniania instalacji.

Aplikacje mogą monitorować te zmiany i odpowiednio na nie reagować.

Aby monitorować rotację FID:

Swift

installationIDObserver = NotificationCenter.default.addObserver(
        forName: .InstallationIDDidChange,
        object: nil,
        queue: nil
) { (notification) in
  // Fetch new Installation ID
  Task {
    await self.fetchInstallationToken()
  }
}

Objective-C

__weak __auto_type weakSelf = self;
self.installationIDObserver = [[NSNotificationCenter defaultCenter]
        addObserverForName: FIRInstallationIDDidChangeNotification
                    object:nil
                     queue:nil
                usingBlock:^(NSNotification * _Nonnull notification) {
    // Fetch new Installation ID
    [weakSelf fetchInstallationsID];
}];

NSPowiadomienie o nazwie NSNotificationName.InstallationIDDidChange jest wysyłane w domyślnym NSNotificationCenter za każdym razem, gdy zostanie przypisany nowy identyfikator FID.

Android

Klienty Kotlin i Java powinny dodać mechanizm ponawiania prób, aby odpowiadać na nieudane wywołania w celu pobierania nowego FID.

JavaScript

Aplikacje internetowe mogą subskrybować punkt zaczepienia onIdChange.

Po utworzeniu nowego identyfikatora FID wywoływane jest subskrybowane wywołanie zwrotne:

await firebase.installations().onIdChange((newId) => {
  console.log(newId);
  // TODO: Handle new installation ID.
});

Dart

FirebaseInstallations.instance.onIdChange.listen((token) {
  print('FID token: $token');
});

Migracja z identyfikatora instancji do instalacji Firebase

Przed wprowadzeniem instalacji Firebase usługa Firebase używała pakietu SDK identyfikatora instancji do obsługi identyfikatorów instalacji aplikacji. Instalacje Firebase mają większe zalety w porównaniu z identyfikatorem instancji w zakresie niezawodności, wydajności i bezpieczeństwa. Aplikacje Firebase, które korzystają z pakietu SDK identyfikatora instancji, powinny zostać przeniesione do instalacji Firebase.

Proces migracji różni się w zależności od aplikacji:

  • Aplikacje, które nie wywołują bezpośrednio interfejsów API identyfikatora instancji, można przenieść, aktualizując wersje pakietu SDK. Zalicza się do niej większość aplikacji Firebase.

  • Aplikacje, które jawnie wywołują interfejs API do identyfikatora instancji, muszą aktualizować wersje pakietu SDK oraz wprowadzać zmiany w kodzie, aby zastąpić metody identyfikatora instancji ich instalacjami w Firebase lub ich odpowiednikami w FCM. Jeśli Twoja aplikacja używa identyfikatora instancji do pobierania tokenów rejestracji FCM lub jawnie używa identyfikatora instancji do kierowania instancji aplikacji lub do innych celów, musisz zaktualizować kod aplikacji.

Obecnie FIS jest zgodny wstecznie ze starszym identyfikatorem identyfikatora instancji Firebase. Usuwanie IID to alternatywna metoda żądania usunięcia danych za pomocą tych pakietów SDK Firebase:

  • iOS 6.14.0 lub starszy
  • Pakiety SDK na Androida przed 27 lutego 2020 r.

Oznacza to, że migracja do instalacji Firebase nie wymaga aplikacji, ale zdecydowanie to zalecamy.

Uaktualnienie do minimalnej wersji pakietu SDK przeznaczonej do instalacji Firebase

Aby przeprowadzić migrację z identyfikatora instancji do instalacji Firebase, upewnij się, że Twoje aplikacje korzystają z co najmniej wymienionego minimalnego numeru wersji tych pakietów SDK Firebase:

Pakiet SDK Firebase Minimalna wersja Androida Minimalna wersja iOS
Komunikacja w chmurze Firebase wersja 20.3.0 wersja 6.34.0
Zdalna konfiguracja Wersja 19.2.0 Wersja 6.24.0
Google Analytics dla Firebase (SDK do pomiaru) Wersja 17.4.4 wersja 6.18.0
Wysyłanie wiadomości w aplikacji Wersja 19.0.7 Wersja 6.24.0
Monitorowanie wydajności Wersja 19.0.8 wersja 6.21.0
Crashlytics wersja 17.2.1 wersja 6.23.0
ML Kit wersja 22.1.2 wersja 6.28.0

Aktualizowanie kodu, który jawnie wywołuje interfejsy API identyfikatora instancji

Jeśli Twoja aplikacja na Androida lub Apple korzysta bezpośrednio z metod pakietu SDK o identyfikatorze instancji, możesz zastąpić to użycie identycznymi alternatywami w pakiecie SDK instalacji Firebase lub pakiecie SDK FCM.

Pobieram identyfikator

Metody pobierania identyfikatorów instancji są zastępowane metodami uzyskiwania identyfikatora instalacji. Przykład:

Przed

Swift

Messaging.messaging().token { token, error in
  if let error = error {
    print("Error fetching remote FCM registration token: \(error)")
  } else if let token = token {
    print("Remote instance ID token: \(token)")
    self.remoteFCMTokenMessage.text = "Remote FCM registration token: \(token)"
  }
}

Objective-C

[[FIRMessaging messaging] tokenWithCompletion:^(NSString * _Nullable token, NSError * _Nullable error) {
   if (error != nil) {
     NSLog(@"Error fetching the remote FCM registration token: %@", error);
   } else {
     NSLog(@"Remote FCM registration token: %@", token);
     NSString* message =
       [NSString stringWithFormat:@"FCM registration token: %@", token];
     self.remoteFCMTokenMessage.text = message;
   }
 }];

Java

FirebaseInstanceId.getInstance().getInstanceId()
        .addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
            @Override
            public void onComplete(@NonNull Task<InstanceIdResult> task) {
                Log.d("IID_TOKEN", task.getResult().getToken());
            }
        });

Kotlin+KTX

FirebaseInstanceId.getInstance().instanceId
        .addOnSuccessListener { result ->
            Log.d("IID_TOKEN", result.token)
        }

Po

Swift

do {
  let id = try await Installations.installations().installationID()
  print("Installation ID: \(id)")
} catch {
  print("Error fetching id: \(error)")
}

Objective-C

[[FIRInstallations installations] installationIDWithCompletion:^(NSString *identifier, NSError *error) {
  if (error != nil) {
    NSLog(@"Error fetching Installation ID %@", error);
    return;
  }
  NSLog(@"Installation ID: %@", identifier);
}];

Java

FirebaseInstallations.getInstance().getId()
        .addOnCompleteListener(new OnCompleteListener<String>() {
    @Override
    public void onComplete(@NonNull Task<String> task) {
        if (task.isSuccessful()) {
            Log.d("Installations", "Installation ID: " + task.getResult());
        } else {
            Log.e("Installations", "Unable to get Installation ID");
        }
    }
});

Kotlin+KTX

FirebaseInstallations.getInstance().id.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        Log.d("Installations", "Installation ID: " + task.result)
    } else {
        Log.e("Installations", "Unable to get Installation ID")
    }
}

Usuwanie identyfikatora

Metody usuwania identyfikatorów instancji są zastępowane metodami usuwania identyfikatorów instalacji Firebase. Przykład:

Przed

Swift

InstanceID.instanceID().deleteID { error in
  if let error = error {
    print("Error deleting instance ID: \(error)")
  }
}

Objective-C

[FIRInstanceID instanceID] deleteIDWithHandler:^(NSError *error) {
  if error != nil {
    NSLog(@"Error deleting instance ID: %@", error);
  }
}];

Android

FirebaseInstanceId.deleteInstanceId();

Po

Swift

func delete(completion: @escaping (Error?) -> Void)

Objective-C

- (void)deleteWithCompletion:(nonnull void (^)(NSError *_Nullable))completion;

Java

FirebaseInstallations.getInstance().delete()
        .addOnCompleteListener(new OnCompleteListener<Void>() {
    @Override
    public void onComplete(@NonNull Task<Void> task) {
        if (task.isSuccessful()) {
            Log.d("Installations", "Installation deleted");
        } else {
            Log.e("Installations", "Unable to delete Installation");
        }
    }
});

Kotlin+KTX

FirebaseInstallations.getInstance().delete().addOnCompleteListener { task ->
    if (task.isComplete) {
        Log.d("Installations", "Installation deleted")
    } else {
        Log.e("Installations", "Unable to delete Installation")
    }
}

Pobieranie tokena rejestracji FCM

Przed wprowadzeniem Instalacji Firebase klienci FCM pobierali tokeny rejestracji z identyfikatora instancji. Teraz pakiet FCM SDK udostępnia metody pobierania tokena rejestracji.

Przed

Java

FirebaseInstanceId.getInstance().getInstanceId()
        .addOnCompleteListener(new OnCompleteListener<InstanceIdResult>() {
            @Override
            public void onComplete(@NonNull Task<InstanceIdResult> task) {
                if (!task.isSuccessful()) {
                    Log.w(TAG, "getInstanceId failed", task.getException());
                    return;
                }

                // Get new Instance ID token
                String token = task.getResult().getToken();

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

Kotlin+KTX

FirebaseInstanceId.getInstance().instanceId
        .addOnCompleteListener(OnCompleteListener { task ->
            if (!task.isSuccessful) {
                Log.w(TAG, "getInstanceId failed", task.exception)
                return@OnCompleteListener
            }

            // Get new Instance ID token
            val token = task.result?.token

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

Swift

Messaging.messaging().token { token, error in
  if let error = error {
    print("Error fetching remote FCM registration token: \(error)")
  } else if let token = token {
    print("Remote instance ID token: \(token)")
    self.remoteFCMTokenMessage.text = "Remote FCM registration token: \(token)"
  }
}

Objective-C

[[FIRMessaging messaging] tokenWithCompletion:^(NSString * _Nullable token, NSError * _Nullable error) {
   if (error != nil) {
     NSLog(@"Error fetching the remote FCM registration token: %@", error);
   } else {
     NSLog(@"Remote FCM registration token: %@", token);
     NSString* message =
       [NSString stringWithFormat:@"FCM registration token: %@", token];
     self.remoteFCMTokenMessage.text = message;
   }
 }];

Po

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

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

Swift

Messaging.messaging().token { token, error in
  if let error = error {
    print("Error fetching FCM registration token: \(error)")
  } else if let token = token {
    print("FCM registration token: \(token)")
    self.fcmRegTokenMessage.text  = "Remote FCM registration token: \(token)"
  }
}

Objective-C

[[FIRMessaging messaging] tokenWithCompletion:^(NSString *token, NSError *error) {
  if (error != nil) {
    NSLog(@"Error getting FCM registration token: %@", error);
  } else {
    NSLog(@"FCM registration token: %@", token);
    self.fcmRegTokenMessage.text = token;
  }
}];