Zarządzanie instalacjami i identyfikatorami Firebase

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

Zwykle usługi Firebase korzystają z usługi instalacji Firebase bez konieczności bezpośredniej interakcji deweloperów z interfejsem FIS API. Są jednak przypadki, w których deweloperzy aplikacji mogą chcieć bezpośrednio wywołać interfejs FIS API, na przykład:

• Aby usunąć instalację Firebase i powiązane z nią dane.
• pobieranie identyfikatorów (identyfikatorów instalacji Firebase) w celu kierowania na konkretne instalacje aplikacji;
• Do pobierania tokenów uwierzytelniania instalacji na potrzeby uwierzytelniania instalacji Firebase.

Aby zacząć bezpośrednio wywoływać interfejs FIS API, dodaj pakiet SDK do aplikacji.

Dodaj do aplikacji pakiet SDK instalacji Firebase

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

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

Usuwanie instalacji Firebase

Dane powiązane z instalacją Firebase zasadniczo nie umożliwiają identyfikacji osób. Mimo to warto dać użytkownikom możliwość 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 powiązane z nimi dane.

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

Jeśli nie wyłączysz w aplikacji wszystkich usług generujących identyfikatory 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 z danymi.

Usuwanie identyfikatora 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:

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

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

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

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

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

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 do serwera pakiet Firebase Admin SDK, jeśli jeszcze go nie masz.

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 te metody usuwają identyfikator FID, gdy są wywoływane z dowolnym bieżącym pakietem SDK Firebase).

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

admin.installations().deleteInstallation(idToDelete);

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

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

  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)

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ą akceptować nowe dane dla tego identyfikatora w ciągu 1–2 dni, a następnie powiadomią aplikację kliencką o usunięciu identyfikatora. 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 przez kilka godzin nadal otrzymywać powiadomienia FCM.

Jeśli chcesz usunąć bieżący identyfikator instalacji Firebase i natychmiast zacząć korzystać z usług Firebase z nowym, niepowiązanym identyfikatorem, użyj interfejsu API klienta, aby obsłużyć usunięcie.

Pobieranie identyfikatorów klientów

Jeśli musisz zidentyfikować konkretne instalacje aplikacji, możesz to zrobić, pobierając identyfikator instalacji Firebase. Na przykład aby utworzyć segmenty instalacji aplikacji na potrzeby importu do BigQuery lub przeprowadzić testy podczas tworzenia Firebase In-App Messaging, możesz zidentyfikować odpowiednie urządzenia i kierować na nie reklamy, używając odpowiednich identyfikatorów instalacji Firebase.

Aby pobrać identyfikator instalacji Firebase:

do {
  let id = try await Installations.installations().installationID()
  print("Installation ID: \(id)")
} catch {
  print("Error fetching id: \(error)")
}
AppDelegate.swift

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

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

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

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

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

Pobieranie tokenów uwierzytelniania instalacji

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

Token uwierzytelniania instalacji to krótkotrwały token okaziciela w formacie tokena sieciowego JSON (JWT) zawierający te informacje o instalacji:

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

Tokena autoryzacji instalacji nie można unieważnić. Pozostaje on ważny do daty ważności. Domyślny czas ważności tokena to 1 tydzień.

Aby pobrać token uwierzytelniania instalacji:

do {
  let result = try await Installations.installations()
    .authTokenForcingRefresh(true)
  print("Installation auth token: \(result.authToken)")
} catch {
  print("Error fetching token: \(error)")
}
AppDelegate.swift

[[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

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

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

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

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

Monitorowanie cyklu życia identyfikatora instalacji Firebase

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

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

Gdy w takich przypadkach aplikacje doświadczają rotacji lub usunięcia identyfikatora FID, przypisywany jest im nowy identyfikator FID. Ponadto token uwierzytelniania instalacji powiązany z usuniętym identyfikatorem FID jest usuwany, niezależnie od jego wieku, i zastępowany nowym tokenem uwierzytelniania instalacji.

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

Aby monitorować rotację FID:

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

__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

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

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

Migracja z identyfikatora instancji do instalacji Firebase

Przed wprowadzeniem instalacji Firebase Firebase korzystał z identyfikatorów instalacji aplikacji z pakietu SDK identyfikatora instancji. Instalacje Firebase zapewniają znaczne korzyści w porównaniu z identyfikatorem instancji pod względem niezawodności, wydajności i bezpieczeństwa. Aplikacje w Firebase, które korzystają z pakietu SDK identyfikatora instancji, powinny przejść na instalacje 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, można przenieść, aktualizując wersje pakietu SDK. Większość aplikacji w Firebase należy do tej kategorii.

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

Obecnie usługa FIS jest zgodna wstecznie ze starszym identyfikatorem instancji Firebase. Usunięcie identyfikatora instancji to alternatywna metoda wysyłania próśb o usunięcie danych za pomocą tych pakietów SDK Firebase:

• iOS 6.14.0 i starsze wersje
• pakiety SDK na Androida sprzed 27 lutego 2020 r.,

Oznacza to, że aplikacje nie muszą przechodzić na instalacje Firebase, ale zdecydowanie zalecamy, aby to zrobić.

Uaktualnianie do minimalnych wersji pakietu SDK w przypadku instalacji Firebase

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

Aktualizowanie kodu, który bezpośrednio wywołuje interfejsy API identyfikatora instancji

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

Pobieranie identyfikatora

Metody uzyskiwania identyfikatorów instancji zostały zastąpione metodami uzyskiwania identyfikatora instalacji. Przykład:

Przed

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

[[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];
    // display message
    NSLog(@"%@", message);
  }
}];

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

FirebaseInstanceId.getInstance().instanceId
        .addOnSuccessListener { result ->
            Log.d("IID_TOKEN", result.token)
        }

Po

do {
  let id = try await Installations.installations().installationID()
  print("Installation ID: \(id)")
} catch {
  print("Error fetching id: \(error)")
}
AppDelegate.swift

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

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

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

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

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

FirebaseInstanceId.deleteInstanceId();

Po

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

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

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

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

Przed

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

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

InstanceID.instanceID().instanceID { result, error in
  if let error = error {
    print("Error fetching instance ID: \(error)")
  } else if let result = result {
    print("Instance ID token: \(result.token)")
  }
}

[[FIRInstanceID instanceID] instanceIDWithHandler:^(FIRInstanceIDResult * _Nullable result,
                                                    NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error fetching instance ID: %@", error);
  } else {
    NSLog(@"Instance ID token: %@", result.token);
  }
}];

Po

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

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

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

[[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];
    // display message
    NSLog(@"%@", message);
  }
}];