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 wybierania urządzeń docelowych w celu dostarczania wiadomości.

Analiza awarii Firebase

Firebase Crashlytics zmienia identyfikator UUID instalacji Crashlytics na podstawie zmian w identyfikatorze instalacji Firebase instancji aplikacji. W przyszłości identyfikator instalacji może zostać wykorzystany do włączenia funkcji usprawniających raportowanie awarii i usługi zarządzania awariami.

Wiadomości w aplikacji Firebase

Funkcja Firebase In-App Messaging wykorzystuje identyfikatory instalacji Firebase do kierowania wiadomości na urządzenia docelowe.

Monitorowanie wydajności Firebase

Monitorowanie wydajności wykorzystuje identyfikatory instalacji Firebase do obliczania liczby unikalnych instalacji Firebase uzyskujących dostęp do zasobów sieciowych, aby zapewnić wystarczającą anonimowość wzorców dostępu. Wykorzystuje także identyfikatory instalacji Firebase w Firebase Remote Config do zarządzania szybkością raportowania zdarzeń związanych z wydajnością.

Zdalna konfiguracja Firebase

Zdalna konfiguracja wykorzystuje identyfikatory instalacji Firebase do wybierania wartości konfiguracyjnych, które mają zostać zwrócone do urządzeń użytkowników końcowych.

Baza Firebase ML

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

Magazyn segmentacji użytkowników Firebase

Magazyn segmentacji użytkowników Firebase przechowuje identyfikatory instalacji Firebase oraz powiązane atrybuty i segmenty, aby zapewnić informacje o kierowaniu innym usługom Firebase, które z nich korzystają.

Zazwyczaj usługi Firebase korzystają z usługi instalacyjnej 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 ukierunkowania instalacji określonych aplikacji.
  • Aby pobrać tokeny autoryzacji 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ść 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, których używa 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 aplikacji delegata application(_:didFinishLaunchingWithOptions:) metoda:

    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, zapoznaj się z instrukcjami 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 pakietu SDK instalacji Firebase dla systemu Android do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle ):

implementation 'com.google.firebase:firebase-installations:17.2.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 konfiguracyjnego Firebase .

Na przykład, jeśli Twoje zależności zostały dodane w pliku Index.html, dodaj zależność w elemencie <head>:

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

Trzepotanie

  1. Z katalogu głównego projektu Flutter uruchom następującą komendę, 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 zazwyczaj nie umożliwiają identyfikacji osoby. 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 i 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 w ciągu 180 dni z działających i kopii zapasowych systemów 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 dotyczącym usuwania i przechowywania .

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

Usuń FID za pomocą wywołania API klienta

Aby usunąć 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");
}];

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 za pomocą wywołania API serwera

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

Po dodaniu pakietu SDK usuń FID poprzez wywołanie funkcji usuwania w wybranym języku (uwaga: z wyjątkiem Node.js, te metody odzwierciedlają nazewnictwo identyfikatorów instancji. Jednak wszystkie one faktycznie usuwają FID po wywołaniu w dowolnej bieżącej bazie 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 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 być ukierunkowane 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ć usunięcie.

Pobierz identyfikatory klientów

Jeśli chcesz zidentyfikować określone instalacje swojej aplikacji, możesz to zrobić, pobierając identyfikator instalacji Firebase. Na przykład, aby utworzyć segmenty instalacji aplikacji na potrzeby importu BiqQuery lub przeprowadzić testy podczas opracowywania komunikatów w aplikacji Firebase, możesz zidentyfikować odpowiednie urządzenia i wybrać dla nich reklamy, korzystając z odpowiednich identyfikatorów 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);
}];

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

Pobierz tokeny autoryzacji instalacji

Usługi Firebase mogą uwierzytelniać instalacje Firebase za pomocą tokenów uwierzytelniających pobranych z FIS. Na przykład podczas projektowania testów A/B dla Remote Config można uwierzytelnić docelowe urządzenie testowe przy użyciu tokena autoryzacji instalacji.

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

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

Token autoryzacji instalacji nie może zostać odwołany i pozostaje ważny do daty wygaśnięcia. Domyślny czas życia tokena wynosi 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)")
})

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

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

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 wykorzystują identyfikatory FID, powinny dodać logikę umożliwiającą monitorowanie potencjalnego usunięcia lub rotacji identyfikatora FID. Oto kilka przypadków, w których FID można usunąć lub zmienić:

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

Gdy w tego typu przypadkach aplikacje zostaną poddane rotacji lub usunięciu FID, zostanie im przypisany nowy FID. Ponadto token autoryzacji instalacji powiązany z usuniętym FID jest usuwany, niezależnie od jego dojrzałości, i zastępowany nowym tokenem autoryzacji 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];
}];

Powiadomienie NSNotification o nazwie NSNotificationName.InstallationIDDidChange jest wysyłane do domyślnego centrum NSNotificationCenter za każdym razem, gdy przypisany zostanie nowy 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 identyfikatora instancji do instalacji Firebase

Przed wprowadzeniem instalacji Firebase Firebase korzystała z pakietu SDK z identyfikatorem instancji w celu uzyskania identyfikatorów 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 z identyfikatorem instancji powinny zostać poddane migracji 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, mogą przeprowadzić migrację, aktualizując swoje wersje pakietu SDK . Większość aplikacji Firebase należy do tej kategorii.

  • Aplikacje, które jawnie wykonują wywołania API do identyfikatora instancji, muszą zaktualizować wersje pakietu SDK i wprowadzić zmiany w kodzie , aby zastąpić metody identyfikatora instancji 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
  • Zestawy SDK systemu Android starsze niż 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 instalacji Instance ID do instalacji Firebase, upewnij się, że Twoje aplikacje korzystają z co najmniej podanych minimalnych numerów wersji następujących zestawów SDK Firebase:

SDK Firebase Minimalna wersja Androida Minimalna wersja iOS
Wiadomości 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 \ (zestaw SDK do pomiarów) v17.4.4 wersja 6.18.0
Wiadomości w aplikacji wersja 19.0.7 wersja 6.24.0
Monitoring wydajności wersja 19.0.8 wersja 6.21.0
Crashlytics wersja 17.2.1 wersja 6.23.0
Zestaw ML v22.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 bezpośrednio korzysta z metod pakietu SDK z identyfikatorem instancji, możesz zastąpić to użycie identycznymi alternatywami w pakiecie SDK instalacji Firebase lub zestawie 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)")
}

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

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 rejestracyjnego FCM

Przed wprowadzeniem instalacji Firebase klienci FCM pobierali tokeny rejestracyjne 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;
  }
}];