Zarządzaj instalacjami Firebase

Usługa instalacji Firebase (FIS) udostępnia identyfikator instalacji Firebase (FID) dla każdego zainstalowanego wystąpienia aplikacji Firebase. Identyfikator instalacji Firebase jest używany wewnętrznie przez te usługi Firebase:

Usługa Firebase Funkcjonalność instalacji Firebase
Wiadomości w chmurze Firebase

Firebase Cloud Messaging używa identyfikatorów instalacji Firebase do kierowania urządzeń do dostarczania wiadomości.

Wysyłanie wiadomości Firebase w aplikacji

Przesyłanie wiadomości Firebase w aplikacji używa identyfikatorów instalacji Firebase, aby kierować urządzenia do dostarczania wiadomości.

Monitorowanie wydajności Firebase

Monitorowanie wydajności wykorzystuje identyfikatory instalacji Firebase do obliczania liczby unikalnych instalacji Firebase, które uzyskują dostęp do zasobów sieciowych, aby zapewnić wystarczającą anonimowość wzorców dostępu. Wykorzystuje również identyfikatory instalacji Firebase ze zdalną konfiguracją Firebase do zarządzania szybkością raportowania zdarzeń wydajności.

Prognozy Firebase

Prognozy używają identyfikatorów instalacji Firebase do kojarzenia instalacji Firebase z projektem i pobierania serii czasowych zdarzeń. Wykorzystuje te zdarzenia, aby umożliwić przewidywanie prawdopodobieństwa wystąpienia określonych przez klienta zdarzeń, a także domyślnie przewidywania wydatków i rezygnacji.

Google Analytics dla Firebase

Google Analytics dla Firebase wykorzystuje dane do dostarczania danych analitycznych i informacji o atrybucji. Dokładne zebrane informacje mogą się różnić w zależności od urządzenia i środowiska.

Zdalna konfiguracja Firebase

Zdalna konfiguracja używa identyfikatorów instalacji Firebase do wybierania wartości konfiguracyjnych, które mają być zwracane do urządzeń użytkowników końcowych.

Firebase ML

Poświadczenia zwane tokenami uwierzytelniania instalacji są używane przez Firebase ML do uwierzytelniania urządzeń podczas interakcji z wystąpieniami aplikacji, na przykład do dystrybucji modeli programistów do wystąpień aplikacji.

Zazwyczaj usługi Firebase korzystają z usługi instalacji Firebase, nie wymagając od programistów bezpośredniej interakcji z interfejsem API FIS. Istnieją jednak przypadki, w których twórcy aplikacji mogą chcieć bezpośrednio wywołać interfejs API FIS, na przykład:

  • Aby usunąć instalację Firebase i powiązane z nią dane.
  • Aby pobrać identyfikatory (identyfikatory instalacji Firebase) w celu wybrania określonych instalacji aplikacji.
  • Aby pobrać tokeny uwierzytelniania instalacji w celu uwierzytelnienia instalacji Firebase.

Aby rozpocząć bezpośrednie wywoływanie interfejsu API FIS, dodaj pakiet SDK do swojej aplikacji.

Dodaj pakiet SDK instalacji Firebase do swojej aplikacji

iOS+

  1. Dodaj zależność instalacji Firebase do swojego pliku Podfile:
    pod 'Firebase/Installations'
  2. Uruchom pod install i otwórz utworzony plik .xcworkspace .
  3. Zaimportuj moduł Firebase do swojego UIApplicationDelegate :

    Szybki

    import Firebase

    Cel C

    @import Firebase;
  4. Skonfiguruj współużytkowane wystąpienie FirebaseApp , zazwyczaj w aplikacji application:didFinishLaunchingWithOptions: metoda:

    Szybki

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

    Cel C

    // Use Firebase library to configure APIs
    [FIRApp configure];

Android

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

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

JavaScript

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

Na przykład, jeśli twoje zależności są dodane w index.html, dodaj zależność w elemencie <head>:

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

Usuń instalację Firebase

Dane powiązane z instalacją Firebase zazwyczaj nie pozwalają na identyfikację osobistą. Mimo to pomocne może być umożliwienie użytkownikom zarządzania tymi danymi i ich usuwania.

Identyfikatory instalacji Firebase są różne dla 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 aplikacji.

Po usunięciu identyfikatora instalacji dane powiązane z tym identyfikatorem instalacji są usuwane z systemów działających i systemów kopii zapasowych wszystkich usług Firebase, które używają identyfikatorów instalacji Firebase do identyfikowania instalacji w ciągu 180 dni. Proces ten został ogólnie opisany w oświadczeniu Google dotyczącym usuwania i przechowywania .

O ile nie wyłączysz wszystkich usług generujących identyfikatory FID w swojej aplikacji, FIS utworzy nowy identyfikator w ciągu kilku dni. Firebase traktuje nowo utworzony identyfikator jako nową instalację Firebase i nie łączy go w żaden sposób z poprzednim identyfikatorem ani danymi.

Usuń FID z wywołaniem API klienta

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

Szybki

Installations.installations().delete { error in
  if let error = error {
    print("Error deleting installation: \(error)")
    return
  }
  print("Installation deleted");
}

Cel C

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

Jawa

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

Usuń FID z wywołaniem API serwera

Aby usunąć identyfikator FID za pomocą wywołania interfejsu API serwera, dodaj pakiet Firebase Admin SDK do swojego serwera , jeśli jeszcze tego nie zrobiłeś.

Po dodaniu pakietu SDK usuń identyfikatory FID za pomocą wywołania funkcji usuwania w wybranym języku (uwaga: z wyjątkiem Node.js te metody odzwierciedlają nazewnictwo identyfikatorów instancji. Jednak wszystkie faktycznie usuwają identyfikatory FID po wywołaniu z dowolną bieżącą wersją Firebase SDK).

Node.js

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

admin.installations().deleteInstallation(idToDelete);

Jawa

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

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

Pyton

  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)

Iść

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

Po usunięciu identyfikatora instalacji Firebase za pomocą wywołania interfejsu API serwera usługi Firebase rozpoczynają proces usuwania danych powiązanych z tym identyfikatorem instalacji, przestają akceptować nowe dane dla tego identyfikatora w ciągu 1-2 dni, a następnie powiadamiają aplikację kliencką że identyfikator został usunięty. Dopóki Firebase nie powiadomi aplikacji klienckiej, niektóre usługi aplikacji mogą nadal kierować na identyfikator — na przykład instalacja Firebase może nadal otrzymywać powiadomienia FCM przez kilka godzin.

Jeśli chcesz usunąć bieżący identyfikator instalacji Firebase i od razu korzystać z usług Firebase z nowym, niepowiązanym identyfikatorem, do obsługi usunięcia użyj interfejsu API klienta.

Pobierz identyfikatory klientów

Jeśli musisz zidentyfikować konkretne instalacje swojej aplikacji, możesz to zrobić, pobierając identyfikator instalacji Firebase. Na przykład, aby przeprowadzić testy podczas tworzenia wiadomości Firebase w aplikacji, możesz zidentyfikować i wybrać odpowiednie urządzenie testowe, używając jego identyfikatora instalacji Firebase.

Aby pobrać identyfikator instalacji Firebase:

Szybki

Installations.installations().installationID { (id, error) in
  if let error = error {
    print("Error fetching id: \(error)")
    return
  }
  guard let id = id else { return }
  print("Installation ID: \(id)")
}

Cel C

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

Jawa

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

Pobierz tokeny uwierzytelniania instalacji

Usługi Firebase mogą uwierzytelniać instalacje Firebase za pomocą tokenów uwierzytelniania pobranych z FIS. Na przykład podczas projektowania testów A/B dla zdalnej konfiguracji można uwierzytelnić docelowe urządzenie testowe za pomocą tokenu uwierzytelniania instalacji.

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

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

Token uwierzytelniania instalacji nie może zostać unieważniony i pozostaje ważny do daty wygaśnięcia. Domyślny okres istnienia tokena to jeden tydzień.

Aby pobrać token uwierzytelniania instalacji:

Szybki

Installations.installations().authTokenForcingRefresh(true, completion: { (result, error) in
  if let error = error {
    print("Error fetching token: \(error)")
    return
  }
  guard let result = result else { return }
  print("Installation auth token: \(result.authToken)")
})

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

Jawa

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

FirebaseInstallations.getInstance().getToken(/* forceRefresh */ true)
    .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);

Monitoruj cykl życia identyfikatora instalacji Firebase

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

  • Odinstalowywanie lub ponowna instalacja aplikacji, na przykład gdy użytkownik końcowy instaluje na nowym urządzeniu.
  • Użytkownik końcowy czyści pamięć podręczną aplikacji lub urządzenia.
  • Usuwanie FID jest wyzwalane w backendzie z powodu braku aktywności aplikacji (obecnie próg to 270 dni braku aktywności).

Gdy w tego typu przypadkach aplikacje doświadczają rotacji lub usuwania identyfikatorów FID, są im przypisywane nowe identyfikatory FID. Ponadto token uwierzytelniania instalacji skojarzony z usuniętym identyfikatorem FID jest usuwany, niezależnie od jego własnej dojrzałości, i zastępowany nowym tokenem uwierzytelniania instalacji.

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

Aby monitorować rotację FID:

Szybki

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

Cel 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];
}];

NSNotification o nazwie NSNotificationName.InstallationIDDidChange .

Android

Klienci Kotlin i Java powinni dodać logikę ponawiania, aby odpowiedzieć na nieudane połączenia w celu pobrania nowego FID.

JavaScript

Aplikacje internetowe mogą subskrybować hak onIdChange .

Za każdym razem, gdy tworzony jest nowy FID, wyzwalane jest wywołanie zwrotne subskrybowanego:

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

Migracja z Instancji ID do instalacji Firebase

Przed wprowadzeniem instalacji Firebase firma Firebase korzystała z pakietu SDK identyfikatorów instancji do identyfikacji instalacji aplikacji. Instalacje Firebase zapewniają znaczną przewagę nad Instance ID pod względem niezawodności, wydajności i bezpieczeństwa. Aplikacje Firebase zależne od pakietu SDK identyfikatora instancji należy migrować do instalacji Firebase.

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

  • Aplikacje, które nie wywołują bezpośrednio interfejsów API identyfikatorów instancji, można przeprowadzić, aktualizując ich wersje pakietu SDK . Większość aplikacji Firebase należy do tej kategorii.

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

Obecnie FIS jest zgodny z poprzednimi wersjami identyfikatora Firebase Instance ID. Usunięcie IID to alternatywna metoda żądania usunięcia danych za pomocą tych pakietów SDK Firebase:

  • iOS 6.14.0 i starsze
  • Android SDK przed 27 lutego 2020 r.

Oznacza to, że migracja aplikacji do instalacji Firebase nie jest wymagana ; jednak jest to wysoce zalecane.

Uaktualnianie do minimalnych wersji SDK dla instalacji Firebase

Aby przeprowadzić migrację z Instance ID do instalacji Firebase, upewnij się, że Twoje aplikacje używają co najmniej wymienionych minimalnych numerów wersji następujących pakietów SDK Firebase:

Pakiet Firebase SDK Minimalna wersja Androida Minimalna wersja iOS
Wiadomości w chmurze Firebase v20.3.0 v6.34.0
Zdalna konfiguracja v19.2.0 v6.24.0
Google Analytics dla Firebase \ (pakiet SDK do pomiarów) v17.4.4 v6.18.0
Wiadomości w aplikacji v19.0.7 v6.24.0
Monitoring wydajności v19.0.8 v6.21.0
Crashlytics v17.2.1 v6.23.0
Zestaw ML v22.1.2 v6.28.0

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

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

Pobieranie identyfikatora

Metody uzyskiwania identyfikatorów instancji są zastępowane metodami uzyskiwania identyfikatorów instalacji. Na przykład:

Zanim

Szybki

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

Cel 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;
   }
 }];

Jawa

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

Później

Szybki

Installations.installations().installationID { (id, error) in
  if let error = error {
    print("Error fetching id: \(error)")
    return
  }
  guard let id = id else { return }
  print("Installation ID: \(id)")
}

Cel C

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

Jawa

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. Na przykład:

Zanim

Szybki

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

Cel C

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

Android

FirebaseInstanceId.deleteInstanceId();

Później

Szybki

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

Cel C

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

Jawa

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 zestaw SDK FCM udostępnia metody pobierania tokenu rejestracji.

Zanim

Jawa

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

Szybki

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

Cel 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;
   }
 }];

Później

Jawa

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

Szybki

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

Cel 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;
  }
}];