Zarządzanie instalacjami Firebase

Usługa instalacji Firebase (FIS) zapewnia Identyfikator instalacji Firebase (FID) dla każdej zainstalowanej instancji aplikacji Firebase. Te Firebase używają wewnętrznie identyfikatora instalacji Firebase usługi:

Usługa Firebase Funkcja instalacji Firebase
Komunikacja w chmurze Firebase

Komunikacja w chmurze Firebase (FCM) wykorzystuje Identyfikatory instalacji Firebase na potrzeby dostarczania wiadomości na urządzenia docelowe.

Firebase Crashlytics

Firebase Crashlytics wykonuje rotację instalacji Crashlytics Identyfikator UUID określony na podstawie zmian w Firebase instancji aplikacji. identyfikator instalacji. W przyszłości identyfikatora instalacji można użyć do włączenia funkcji, które lepszego raportowania o awariach i zarządzania awariami.

Wysyłanie wiadomości w aplikacji Firebase

Zastosowanie funkcji Firebase Wysyłanie wiadomości w aplikacji Identyfikatory instalacji Firebase na potrzeby dostarczania wiadomości na urządzenia docelowe.

Monitorowanie wydajności Firebase

Monitorowanie wydajności korzysta z identyfikatorów instalacji Firebase do obliczania liczby unikalnych instalacji Firebase, które uzyskują dostęp zasobów sieciowych, aby wzorce dostępu były wystarczająco anonimowych. Wykorzystuje też Identyfikatory instalacji Firebase korzystające ze Zdalnej konfiguracji Firebase aby zarządzać szybkością raportowania zdarzeń skuteczności.

Zdalna konfiguracja Firebase

Zdalna konfiguracja używa identyfikatorów instalacji Firebase aby wybrać konfigurację z wartościami, które mają zostać zwrócone na urządzenia użytkowników.
Firebase ML

Wywołano dane logowania tokenów uwierzytelniania instalacji, które są używane przez Firebase ML do uwierzytelnianie urządzenia podczas interakcji z aplikacją np. w celu rozpowszechniania modeli programisty w instancjach aplikacji.

Miejsce na dane segmentacji użytkowników Firebase

Pamięć segmentów użytkowników Firebase przechowuje identyfikatory instalacji Firebase oraz powiązane atrybuty i segmenty, które dostarczają informacji o kierowaniu do innych usług Firebase, które z nich korzystają.

Zwykle usługi Firebase korzystają z usługi instalacji Firebase bez i wymagają od programistów bezpośredniej interakcji z interfejsem FIS API. Jednak w niektórych przypadkach deweloperzy aplikacji mogą chcieć bezpośrednio wywoływać tag 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 określonych instalacji aplikacji.
  • Aby pobrać tokeny uwierzytelniania instalacji w celu uwierzytelnienia Firebase instalacji.

Jak zacząć korzystać z połączenia bezpośredniego interfejsu FIS API, należy dodać pakiet SDK do 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 UIApplicationDelegate, jak i wszelkie 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 FirebaseApp współdzielonej instancji w uprawnieniach przedstawiciela aplikacji Metoda application(_:didFinishLaunchingWithOptions:):

    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ć i dołączyć przedstawiciela aplikacji. do struktury App za pomocą UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor Musisz też wyłączyć przełączanie przekazywania dostępu do aplikacji. Dla: 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 Plik 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ługiwane automatycznie. Może też zaistnieć konieczność zaktualizowania Obiekt konfiguracji Firebase.

Jeśli na przykład zależności zostały dodane w pliku index.html, dodaj atrybut zależność w sekcji <head> element:

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

Flutter

  1. W katalogu głównym projektu Flutter uruchom to polecenie polecenia instalacji wtyczki instalacyjnej Firebase:

    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 zwykle nie są powiązane z osobą i identyfikacji. Mimo to pomocne może być umożliwiać użytkownikom zarządzanie tymi danymi i ich usuwanie.

Identyfikatory instalacji Firebase są inne dla każdej instalacji aplikacji; różne aplikacje na tym samym urządzeniu mają różne Identyfikatory instalacji Firebase. Identyfikatory instalacji Firebase identyfikują aplikację instalacji i danych powiązanych tych instalacji.

Po usunięciu identyfikatora instalacji powiązane z nim dane jest usuwany z systemów aktywnych i kopii zapasowych wszystkich systemów Usługi Firebase, które do identyfikowania instalacji używają identyfikatorów instalacji Firebase w ciągu 180 dni. Proces ten opisano szczegółowo w oświadczenie o usunięciu i przechowywaniu danych.

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

Usuń FID z wywołaniem interfejsu API klienta

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

Swift

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

Objective-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 z wywołaniem interfejsu API serwera

Aby usunąć FID za pomocą interfejsu API serwera dodaj do swojego serwera pakiet SDK Firebase Admin, jeśli jeszcze nie zostało to zrobione.

Po dodaniu pakietu SDK usuń identyfikatory FID, używając wywołania w wybranym języku (uwaga: oprócz Node.js odzwierciedlają nazwy identyfikatorów instancji. Wszystkie jednak usuwają FID w przypadku wywołania z dowolnego bieżącego 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, Firebase rozpoczną proces usuwania danych powiązanych z tym identyfikatorem instalacji, będzie akceptować nowe dane dla tego dokumentu tożsamości w ciągu 1–2 dni, a potem powiadomić aplikacji klienckiej, w której usunięto identyfikator. Dopóki Firebase nie powiadomi aplikacji klienckiej, usług aplikacji może nadal być kierowana na identyfikator – np. Firebase instalacja może wciąż otrzymywać powiadomienia FCM przez kilka godz.

Jeśli chcesz usunąć bieżący identyfikator instalacji Firebase i od razu użyć Usługi Firebase z nowym, niepowiązanym identyfikatorem – użyj interfejsu API klienta mogą zająć się usunięciem danych.

Pobieranie identyfikatorów klientów

Jeśli wymagasz wskazania określonych instalacji aplikacji, Można to zrobić, pobierając identyfikator instalacji Firebase. Aby na przykład utworzyć segmentów instalacji aplikacji do importu przy użyciu BigQuery lub testowania funkcji Firebase Wysyłanie wiadomości w aplikacji, kierować reklamy na odpowiednie urządzenia, używając 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)")
}
AppDelegate.swift

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

Pobieranie tokenów uwierzytelniania instalacji

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

Instalacyjny token uwierzytelniania to krótkotrwały token okaziciela w formacie tokena sieciowego JSON (JWT) zawierającego następujące informacje dla instalacja:

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

Token uwierzytelniania instalacji nie może zostać unieważniony. Pozostanie on ważny do jej datę ważności. 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)")
}
AppDelegate.swift

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

Monitorowanie cyklu życia identyfikatora instalacji Firebase

Identyfikatory instalacji Firebase podczas normalnego działania aplikacji (FID) nie wymagają specjalnego monitorowania. Jednak aplikacje, które pobierają i używają identyfikatorów FID, powinny dodaj logikę do monitorowania potencjalnego usunięcia lub rotacji FID. Oto kilka przypadków, w których Elementy FID mogą być usuwane lub rotowane:

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

Jeśli w aplikacjach występuje rotacja lub usuwanie FID w przypadku różnych rodzajów przypadków przypisywany jest nowy FID. Dodatkowo token uwierzytelniania instalacji powiązany z usuniętym identyfikatorem FID to jest usuwana niezależnie od jej dojrzałości i zostaje zastąpiona nową token 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()
  }
}
AppDelegate.swift

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

Powiadomienie NS Notification o nazwie NSNotificationName.InstallationIDDidChange to publikowane w domyślnym NSnotificationCenter za każdym razem, gdy nowe Przypisano FID.

Android

Klienty Kotlin i Java powinny dodać mechanizm ponawiania prób, aby odpowiadać na nieudane wywołania aby pobrać nowy identyfikator FID.

JavaScript

Aplikacje internetowe mogą subskrybować punkt zaczepienia onIdChange.

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

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 opierała się ona na Pakiet SDK identyfikatora instancji na potrzeby identyfikatorów instalacji aplikacji. Instalacje Firebase ma wiele zalet w porównaniu z identyfikatorem instancji, jeśli chodzi o niezawodność, wydajność i o bezpieczeństwie. Aplikacje Firebase, które zależą od 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, mogą migrować przez aktualizacji pakietów 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 i wprowadź zmiany w kodzie, aby zastąpić identyfikator instancji. wraz z ich Instalacje Firebase lub ich odpowiedniki w FCM. Jeśli aplikacja używa Identyfikator instancji do pobierania tokenów rejestracji FCM lub jawnego użycia Identyfikator instancji, który chcesz wykorzystać w instancjach aplikacji lub w innym celu, musisz wykonać zaktualizować kod aplikacji.

Obecnie FIS jest zgodna wstecznie ze starszym identyfikatorem identyfikatora instancji Firebase. Usuwanie IID to alternatywna metoda przesyłania prośby o usunięcie danych za pomocą te pakiety 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 musi obejmować aplikacji. jednak zdecydowanie to zalecamy.

Uaktualnienie do minimalnej wersji pakietu SDK przeznaczonej do instalacji Firebase

Aby przeprowadzić migrację z identyfikatora instancji do instalacji Firebase, sprawdź, czy aplikacje używają co najmniej podanych minimalnych wersji numerów wersji te pakiety 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\ (Pakiet SDK do pomiarów skuteczności) 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 wykorzystanie w instalacjach Firebase identycznymi zamiennikami SDK lub pakiet SDK FCM.

Pobieram identyfikator

Metody pobierania identyfikatorów instancji są zastępowane metodami pobierania instalacji ID. 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)")
}
AppDelegate.swift

Objective-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 Identyfikatory 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");
        }
    }
});
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 pobrano tokeny rejestracji z identyfikatora instancji. Teraz pakiet SDK FCM 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;
  }
}];