Zarządzanie instalacjami Firebase

Usługa instalacji Firebase (FIS) udostępnia 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	Firebase funkcji instalacji
Firebase Cloud Messaging	Firebase Cloud Messaging używa identyfikatorów instalacji Firebase, aby kierować wiadomości na określone urządzenia.
Firebase Crashlytics	Firebase Crashlytics zamienia 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, które ułatwiają zgłaszanie awarii i zarządzanie nimi.
Firebase In-App Messaging	Firebase In-App Messaging używa identyfikatorów instalacji Firebase, aby kierować wiadomości na określone urządzenia.
Firebase Performance Monitoring	Performance Monitoring używa identyfikatorów instalacji Firebase do obliczania liczby unikalnych instalacji Firebase, które uzyskują dostęp do zasobów sieci, aby zapewnić wystarczającą anonimowość wzorców dostępu. Używa ona też identyfikatorów instalacji Firebase z Firebase Remote Config do zarządzania częstotliwością raportowania zdarzeń skuteczności.
Firebase Remote Config	Remote Config używa identyfikatorów instalacji Firebase, aby wybrać wartości konfiguracji, które mają zostać zwrócone na urządzenia użytkowników.
Firebase ML	Dane logowania nazywane tokenami uwierzytelniania instalacji są używane przez Firebase ML do uwierzytelniania urządzenia podczas interakcji z instancjami aplikacji, na przykład do rozpowszechniania modeli deweloperów w przypadku instancji aplikacji.
Pamięć segmentacji użytkowników Firebase	Pamięć masowa segmentacji użytkowników Firebase przechowuje identyfikatory instalacji Firebase oraz powiązane atrybuty i segmenty, aby udostępniać informacje o kierowaniu innym usługom Firebase, które z nich korzystają.

Uwaga: dodatkowe usługi Firebase używają różnych typów danych logowania do identyfikowania lub kierowania na instancje aplikacji. Więcej informacji znajdziesz w artykule Prywatność i bezpieczeństwo w Firebase.

Jeśli połączysz projekt Firebase z usługą w Google Analytics, Google Analytics może używać identyfikatorów instalacji Firebase do dostarczania informacji analitycznych i przypisywania udziału w konwersji. Dokładne informacje zbierane przez Google mogą się różnić w zależności od urządzenia i otoczenia.

Usługi Firebase zwykle korzystają z usługi instalacji Firebase, nie wymagając od deweloperów bezpośredniej interakcji z interfejsem FIS API. Jednak niekiedy deweloperzy aplikacji mogą chcieć bezpośrednio wywołać interfejs FIS API, na przykład:

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

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

Dodaj do aplikacji pakiet SDK instalacji Firebase

iOS+

1. Dodaj do pliku Podfile zależność dla instalacji Firebase:

   pod 'FirebaseInstallations'

2. Uruchom pod install i otwórz utworzony plik .xcworkspace.
3. Zaimportuj moduł FirebaseCore w pliku UIApplicationDelegate oraz wszystkie inne moduły Firebase, których używa delegowany obiekt aplikacji. Aby na przykład użyć właściwości Cloud Firestore i Authentication:

   SwiftUI

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

   Swift

   import FirebaseCore
   import FirebaseFirestore
   import FirebaseAuth
   // ...
         

   Objective-C

   @import FirebaseCore;
   @import FirebaseFirestore;
   @import FirebaseAuth;
   // ...
         

4. Skonfiguruj współdzieloną instancję FirebaseApp w metodzie application(_:didFinishLaunchingWithOptions:) w delegacie aplikacji:

   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ć obiekt delegujący aplikacji i dołączyć go do struktury App za pomocą funkcji UIApplicationDelegateAdaptor lub NSApplicationDelegateAdaptor. Musisz też wyłączyć swizlowanie zastępników aplikacji. Więcej informacji znajdziesz w instrukcjach 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ść z Androidowym pakietem SDK Firebase do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle):

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

JavaScript

W zależności od tego, jak hostowana jest aplikacja internetowa, konfiguracja może zostać obsłużona automatycznie lub konieczne może być zaktualizowanie obiektu konfiguracji Firebase.

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

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

Flutter

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

   flutter pub add firebase_app_installations
   

2. Zbuduj ponownie projekt:

   flutter run
   

3. Zaimportuj wtyczkę instalacji Firebase:

   import 'package:firebase_app_installations/firebase_app_installations.dart';
   

Usuwanie instalacji Firebase

Dane powiązane z instalacją Firebase zazwyczaj nie umożliwiają identyfikacji osoby. Mimo to warto dać użytkownikom możliwość zarządzania tymi danymi i ich usuwania.

Firebaseidentyfikatory instalacji są różne w przypadku każdej instalacji każdej aplikacji; różne aplikacje na tym samym urządzeniu mają różne Firebaseidentyfikatory instalacji. Identyfikatory instalacji Firebase umożliwiają identyfikację instalacji aplikacji oraz danych powiązanych z tymi instalacjami.

Gdy usuniesz identyfikator instalacji, dane powiązane z tym identyfikatorem zostaną usunięte z systemów produkcyjnych i systemów zapasowych wszystkich usług Firebase, które używają identyfikatorów instalacji Firebase do identyfikowania instalacji, w ciągu 180 dni. Ogólny opis tego procesu znajdziesz w oświadczeniu Google na temat usuwania i przechowywania danych.

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

Uwaga: Google Analytics dla Firebase używa własnego identyfikatora do śledzenia danych Analytics. Usunięcie identyfikatora instalacji Firebase nie powoduje usunięcia danych Analytics. Dowiedz się, jak usunąć dane Analytics powiązane z użytkownikami.

Usuwanie identyfikatora FID za pomocą wywołania interfejsu API klienta

Aby usunąć identyfikatory FID wygenerowane przez usługi Firebase, wywołaj odpowiednią metodę z poziomu 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

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

Usuwanie identyfikatora FID za pomocą wywołania interfejsu API serwera

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

Po dodaniu pakietu SDK usuń identyfikatory FID, wywołując funkcję usuwania w wybranym języku (uwaga: te metody odzwierciedlają nazewnictwo identyfikatora instancji, z wyjątkiem Node.js). Jednak wszystkie te metody faktycznie usuwają identyfikator FID, gdy są wywoływane z dowolnym bieżącym pakietem 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 za pomocą wywołania interfejsu API serwera, usługi Firebase rozpoczną proces usuwania danych powiązanych z tym identyfikatorem instalacji, przestaną przyjmować nowe dane dla tego identyfikatora w ciągu 1–2 dni, a potem powiadomią aplikację klienta o usunięciu identyfikatora. Dopóki Firebase nie powiadomi aplikacji klienta, niektóre usługi aplikacji mogą nadal kierować reklamy do tego identyfikatora. Na przykład instalacja Firebase może przez kilka godzin nadal otrzymywać powiadomienia FCM.

Jeśli chcesz usunąć bieżący identyfikator instalacji Firebase i natychmiast korzystać z usług Firebase z nowym, niezwiązanym z nim identyfikatorem, użyj interfejsu API klienta, aby usunąć ten identyfikator.

Pobieranie identyfikatorów klienta

Jeśli chcesz zidentyfikować konkretne instalacje aplikacji, możesz to zrobić, pobierając identyfikator instalacji Firebase. Na przykład aby utworzyć segmenty instalacji aplikacji do importowania do BigQuery lub przeprowadzić testy podczas tworzenia Firebase In-App Messaging, możesz zidentyfikować i wycelować 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

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 pobieranych z FIS. Na przykład podczas projektowania testów A/B dla Remote Config możesz uwierzytelnić docelowe urządzenie testowe za pomocą tokena uwierzytelniania instalacji.

Ważne: nie należy mylić tokenów autoryzacji instalacji z tokenami używanymi przez Firebase Authentication. Te różne typy tokenów różnią się zastosowaniem i nie można ich zastępować innymi.

Token autoryzacji instalacji to krótkotrwały token tożsamości w formacie tokena sieciowego JSON (JWT), który zawiera te informacje dotyczące instalacji:

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

Token autoryzacji instalacji nie może zostać cofnięty i pozostanie ważny do daty jego wygaśnięcia. Domyślny okres ważności tokena to 1 tydzień.

Aby pobrać token uwierzytelniający instalację:

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

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

Podczas normalnego działania aplikacji identyfikatory instalacji (FID) nie wymagają specjalnego monitorowania.Firebase Aplikacje, które wyraźnie pobierają i używają identyfikatorów FID, powinny jednak dodać logikę, która będzie monitorować ich ewentualne usuwanie lub rotację. Oto kilka przypadków, w których identyfikatory FID mogą zostać usunięte lub zastąpione:

• odinstalowanie lub ponowne zainstalowanie aplikacji, na przykład gdy użytkownik zainstaluje ją na nowym urządzeniu;
• Użytkownik oczyszcza pamięć podręczną aplikacji lub urządzenia.
• Usunięcie identyfikatora FID jest wywoływane na zapleczu z powodu braku aktywności w aplikacji (obecnie próg wynosi 270 dni).

Gdy w takich przypadkach aplikacje mają przypisane nowe identyfikatory FID, są one usuwane lub zastępowane. Ponadto token autoryzacji instalacji powiązany z usuniętym identyfikatorem FID zostaje usunięty niezależnie od jego dojrzałości i zastąpiony nowym tokenem autoryzacji 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

Gdy przypisano nowy identyfikator FID, do domyślnego obiektu NSNotificationCenter jest wysyłana wiadomość NSNotification o nazwie NSNotificationName.InstallationIDDidChange.

Android

Klienci Kotlin i Java powinni dodać logikę ponownego próbowania, aby odpowiadać na nieudane wywołania w celu pobrania nowego identyfikatora FID.

JavaScript

Aplikacje internetowe mogą subskrybować element onIdChange.

Za każdym razem, gdy utworzono nowy identyfikator FID, wywoływana jest funkcja wywołania zwrotnego:

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

Dart

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

Przenoszenie z identyfikatora instancji na Firebase instalacji

Przed wprowadzeniem instalacji Firebase Firebase korzystało z identyfikatorów instalacji aplikacji w pakiecie SDK Identyfikator instancji. Firebase instalacji zapewniają znaczne korzyści w zakresie niezawodności, wydajności i bezpieczeństwa w porównaniu z identyfikatorem instancji. Aplikacje Firebase, które korzystają z pakietu SDK Identyfikator 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 Identyfikator instancji, mogą przejść na nową wersję, aktualizując pakiety SDK. Większość aplikacji Firebase należy do tej kategorii.

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

Obecnie FIS jest zgodny wstecz z używanym wcześniej identyfikatorem Firebase Instance ID. Usuwanie identyfikatora IID to alternatywna metoda prośby o usunięcie danych za pomocą tych pakietów SDK Firebase:

• iOS 6.14.0 i starsze
• Pakiety SDK Androida starsze niż z 27 lutego 2020 r.

Oznacza to, że nie musisz migrować aplikacji do wersji Firebase, ale zdecydowanie zalecamy to zrobić.

Aktualizowanie do minimalnych wersji pakietu SDK w przypadku instalacji Firebase

Aby przejść z identyfikatora instancji na instalacje Firebase, upewnij się, że Twoje aplikacje korzystają z co najmniej tych wersji pakietów SDK Firebase:

Pakiet SDK Firebase	Minimalna wersja Androida	Minimalna wersja iOS
Komunikacja w chmurze Firebase	20.3.0	6.34.0
Zdalna konfiguracja	19.2.0	6.24.0
Google Analytics dla Firebase (pakiet SDK do pomiarów)	17.4.4	6.18.0
Wysyłanie wiadomości w aplikacji	v19.0.7	6.24.0
Monitorowanie wydajności	v19.0.8	6.21.0
Crashlytics	v17.2.1	6.23.0
ML Kit	22.1.2	6.28.0

Aktualizowanie kodu, który jawnie wywołuje interfejsy Instance ID API

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

Pobieranie identyfikatora

Metody służące do uzyskiwania identyfikatorów instancji zostały zastąpione metodami służącymi do uzyskiwania identyfikatorów instalacji. Przykład:

Przed

Swift

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

Objective-C

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

Java

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

Kotlin

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

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 zostały zastąpione metodami usuwania identyfikatorów instalacji Firebase. Przykład:

Przed

Swift

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

Objective-C

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

Android

FirebaseInstanceId.deleteInstanceId();

Po

Swift

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

Objective-C

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

Java

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

Kotlin

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. Obecnie pakiet SDK FCM udostępnia metody umożliwiające pobranie 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

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

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