Zarządzaj instalacjami Firebase

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

Usługa Firebase Funkcjonalność instalacji Firebase
Przesyłanie wiadomości w chmurze Firebase

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

Crashlytics Firebase

Firebase Crashlytics rotuje identyfikator UUID instalacji Crashlytics na podstawie zmian w identyfikatorze instalacji Firebase instancji aplikacji. W przyszłości identyfikator instalacji może być używany do włączania funkcji usprawniających usługi raportowania awarii i zarządzania awariami.

Wiadomości w aplikacji Firebase

Firebase In-App Messaging używa identyfikatorów instalacji Firebase do kierowania urządzeń na potrzeby 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 upewnić się, że wzorce dostępu są wystarczająco anonimowe. Wykorzystuje również identyfikatory instalacji Firebase z Firebase Remote Config do zarządzania częstotliwością raportowania zdarzeń związanych z wydajnością.

Zdalna konfiguracja Firebase

Zdalna konfiguracja używa identyfikatorów instalacji Firebase do wybierania wartości konfiguracyjnych, które mają zostać zwrócone na urządzenia 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 instancjami aplikacji, na przykład w celu dystrybucji modeli deweloperskich do instancji aplikacji.

Magazyn segmentacji użytkowników Firebase

Firebase User Segmentation Storage przechowuje identyfikatory instalacji Firebase oraz powiązane atrybuty i segmenty w celu dostarczania informacji o kierowaniu do innych usług Firebase, które ich używają.

Zazwyczaj usługi Firebase korzystają z usługi instalacji Firebase bez konieczności bezpośredniej interakcji programistów 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 dane powiązane z instalacją.
  • Aby pobrać identyfikatory (identyfikatory instalacji Firebase) w celu kierowania na określone instalacje aplikacji.
  • Aby pobrać tokeny autoryzacji instalacji w celu uwierzytelnienia instalacji Firebase.

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

Dodaj pakiet SDK instalacji Firebase do swojej aplikacji

iOS+

  1. Dodaj zależność dla instalacji Firebase do swojego Podfile: 
    pod 'FirebaseInstallations'
  2. Uruchom pod install i otwórz utworzony plik .xcworkspace .
  3. Zaimportuj moduł FirebaseCore do swojego UIApplicationDelegate , a także wszelkie inne moduły Firebase, z których korzysta delegat aplikacji. Na przykład, aby użyć Cloud Firestore i uwierzytelniania:

    SwiftUI

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

    Szybki

    import FirebaseCore
import FirebaseFirestore
import FirebaseAuth
// ...

    Cel C

    @import FirebaseCore;
@import FirebaseFirestore;
@import FirebaseAuth;
// ...
  4. Skonfiguruj udostępnioną instancję FirebaseApp w metodzie application application(_:didFinishLaunchingWithOptions:) delegata aplikacji:

    SwiftUI

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

    Szybki

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

    Cel C

    // Use Firebase library to configure APIs
[FIRApp configure];
  5. Jeśli używasz SwiftUI, musisz utworzyć delegata aplikacji i dołączyć go do struktury App za pośrednictwem UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor . Musisz także wyłączyć przełączanie delegatów aplikacji. Aby uzyskać więcej informacji, zobacz instrukcje SwiftUI .

    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ść dla instalacji Firebase Android SDK do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle ):

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

JavaScript

W zależności od tego, jak hostowana jest Twoja aplikacja internetowa, konfiguracja może być obsługiwana automatycznie lub może być konieczna aktualizacja obiektu konfiguracyjnego Firebase .

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

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

Trzepotanie

  1. W katalogu głównym projektu Flutter uruchom następujące polecenie, aby zainstalować wtyczkę instalacyjną Firebase:

    flutter pub add firebase_app_installations

  2. Przebuduj swój projekt:

    flutter run

  3. Zaimportuj wtyczkę instalacyjną Firebase:

    import 'package:firebase_app_installations/firebase_app_installations.dart';

Usuń instalację Firebase

Dane powiązane z instalacją Firebase zasadniczo nie umożliwiają identyfikacji użytkownika. 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.

Gdy usuniesz identyfikator instalacji, dane powiązane z tym identyfikatorem instalacji zostaną usunięte z aktywnych i zapasowych systemów wszystkich usług Firebase, które używają identyfikatorów instalacji Firebase do identyfikowania instalacji w ciągu 180 dni. Ten proces jest szczegółowo opisany w oświadczeniu Google dotyczącym usuwania i przechowywania .

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

Usuń FID za pomocą wywołania interfejsu 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");
}
AppDelegate.swift

Cel C

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

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");
        }
    }
});
MainActivity.java

Kotlin+KTX

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

JavaScript

await firebase.installations().delete();
index.js

Dart

await FirebaseInstallations.instance.delete();

Usuń FID za pomocą wywołania interfejsu API serwera

Aby usunąć 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, wywołując funkcję usuwania w wybranym języku (uwaga: z wyjątkiem Node.js te metody odzwierciedlają nazewnictwo identyfikatorów instancji. Jednak wszystkie one faktycznie usuwają FID, gdy są wywoływane z dowolną obecną bazą Firebase SDK).

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

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

Gdy usuniesz identyfikator 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ć reklamy na ten 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 natychmiast korzystać z usług Firebase z nowym, niepowiązanym identyfikatorem, użyj interfejsu API klienta, aby obsłużyć usuwanie.

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 opracowywania wiadomości Firebase w aplikacji, możesz zidentyfikować i skierować odpowiednie urządzenie testowe za pomocą 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)")
}
AppDelegate.swift

Cel C

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

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");
        }
    }
});
MainActivity.java

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")
    }
}
MainActivity.kt

JavaScript

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

Dart

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

Pobierz tokeny autoryzacji instalacji

Usługi Firebase mogą uwierzytelniać instalacje Firebase za pomocą tokenów uwierzytelniania pobranych z FIS. Na przykład, projektując testy A/B dla Remote Config, możesz uwierzytelnić docelowe urządzenie testowe za pomocą tokena autoryzacji instalacji.

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

  • Identyfikator instalacji Firebase
  • Powiązany projekt ( projectNumber )
  • Powiązany identyfikator aplikacji Firebase ( appId )
  • Data wygaśnięcia tokenu

Token autoryzacji instalacji nie może zostać odwołany i pozostaje ważny do daty wygaśnięcia. Domyślny czas życia tokena to jeden tydzień.

Aby pobrać token autoryzacji 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)")
})
AppDelegate.swift

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]);
}];
ObjCSnippets.m

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");
        }
    }
});
MainActivity.java

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")
        }
    }
MainActivity.kt

JavaScript

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

Dart

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

Monitoruj cykl ż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ą FID, powinny dodać logikę do monitorowania potencjalnego usunięcia lub rotacji FID. Oto kilka przypadków, w których FID można usunąć lub obrócić:

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

Gdy aplikacje doświadczają rotacji lub usuwania FID w tego rodzaju przypadkach, przypisywany jest im nowy FID. Ponadto token autoryzacji instalacji powiązany z usuniętym FID jest usuwany, niezależnie od jego własnej dojrzałości, i zastępowany nowym tokenem autoryzacji instalacji.

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

Aby monitorować rotację FID:

Szybki

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

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];
}];
ObjCSnippets.m

NSNotification o nazwie NSNotificationName.InstallationIDDidChange jest wysyłane do domyślnego NSNotificationCenter za każdym razem, gdy jest przypisywany nowy identyfikator FID.

Android

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

JavaScript

Aplikacje internetowe mogą subskrybować hak onIdChange .

Za każdym razem, gdy tworzony jest nowy FID, uruchamiane 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');
});

Przeprowadź migrację z Instance ID do instalacji Firebase

Przed wprowadzeniem instalacji Firebase Firebase polegała na pakiecie SDK Instance ID do identyfikacji instalacji aplikacji. Instalacje Firebase zapewniają znaczną przewagę nad identyfikatorem instancji pod względem niezawodności, wydajności i bezpieczeństwa. Aplikacje Firebase, które są zależne od pakietu SDK identyfikatora instancji, powinny zostać przeniesione 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 identyfikatora instancji, mogą migrować, aktualizując wersje swojego pakietu SDK . Większość aplikacji Firebase należy do tej kategorii.

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

Obecnie FIS jest wstecznie kompatybilny ze starszym identyfikatorem Firebase Instance ID. Usunięcie identyfikatora IID to alternatywna metoda żądania usunięcia danych za pomocą tych pakietów SDK Firebase:

  • iOS 6.14.0 i starsze
  • Pakiety SDK Androida sprzed 27 lutego 2020 r

Oznacza to, że aplikacje nie muszą migrować do instalacji Firebase; jednak jest to wysoce zalecane.

Aktualizacja 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:

SDK Firebase Minimalna wersja Androida Minimalna wersja iOS
Przesyłanie wiadomości w chmurze Firebase v20.3.0 v6.34.0
Zdalna konfiguracja wersja 19.2.0 v6.24.0
Google Analytics dla Firebase \ (pakiet SDK do pomiarów) v17.4.4 v6.18.0
Wiadomości w aplikacji wersja 19.0.7 v6.24.0
Monitoring wydajności wersja 19.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 identyfikatora instancji

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

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

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

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)")
}
AppDelegate.swift

Cel C

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

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");
        }
    }
});
MainActivity.java

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")
    }
}
MainActivity.kt

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

Po

Szybki

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

Cel 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");
        }
    }
});
MainActivity.java

Kotlin+KTX

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

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

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

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

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

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