Blockhaus

Wichtig :Für eine aktualisierte Nutzerfreundlichkeit und andere Verbesserungen sollten Sie stattdessen Passkeys mit Credential Manager verwenden.

Viele Nutzer verwalten ihre Anmeldedaten weiterhin selbst, wenn sie ein neues Android-Gerät einrichten. Dieser manuelle Prozess kann schwierig werden und führt oft zu einer schlechten Nutzererfahrung. Die Block Store API, eine Bibliothek, die auf Google Play-Diensten basiert, soll dieses Problem lösen. Sie bietet Apps die Möglichkeit, Nutzeranmeldedaten zu speichern, ohne dass die Komplexität oder das Sicherheitsrisiko entsteht, das mit dem Speichern von Nutzerpasswörtern verbunden ist.

Mit der Block Store API kann Ihre App Daten speichern, die sie später abrufen kann, um Nutzer auf einem neuen Gerät neu zu authentifizieren. Dadurch wird die Nutzererfahrung verbessert, da Nutzer beim erstmaligen Starten Ihrer App auf dem neuen Gerät keinen Anmeldebildschirm sehen.

Die Verwendung von Block Store bietet unter anderem folgende Vorteile:

• Lösung für die verschlüsselte Speicherung von Anmeldedaten für Entwickler. Anmeldedaten werden nach Möglichkeit mit Ende-zu-Ende-Verschlüsselung geschützt.
• Tokens anstelle von Nutzernamen und Passwörtern speichern
• Anmeldevorgänge vereinfachen
• Nutzern die Verwaltung komplexer Passwörter erleichtern
• Google überprüft die Identität des Nutzers.

Hinweis :Die Verwendung von Block Store schränkt den Nutzer nicht in der Art der Anmeldedaten ein, die verwendet werden können. Nutzer können sich mit ihrem Nutzernamen und Passwort, ihrem Google-Konto oder einem anderen föderierten Identitätsanbieter anmelden und Block Store funktioniert weiterhin.

Hinweis

Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre App vorzubereiten.

App konfigurieren

Fügen Sie in der Datei build.gradle auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects ein:

buildscript {
  repositories {
    google()
    mavenCentral()
  }
}

allprojects {
  repositories {
    google()
    mavenCentral()
  }
}

Fügen Sie die Abhängigkeit für Google Play-Dienste für die Block Store API der Gradle-Build-Datei Ihres Moduls hinzu, die in der Regel app/build.gradle ist:

dependencies {
  implementation 'com.google.android.gms:play-services-auth-blockstore:16.4.0'
}

Funktionsweise

Mit Block Store können Entwickler bis zu 16 Byte-Arrays speichern und wiederherstellen. So können Sie wichtige Informationen zur aktuellen Nutzersitzung speichern und haben die Flexibilität, diese Informationen nach Belieben zu speichern. Diese Daten können mit Ende-zu-Ende-Verschlüsselung geschützt werden. Die Infrastruktur, die Block Store unterstützt, basiert auf der Infrastruktur für Sicherung und Wiederherstellung.

In diesem Leitfaden wird der Anwendungsfall des Speicherns des Tokens eines Nutzers im Block Store behandelt. Im Folgenden wird beschrieben, wie eine App, die Block Store nutzt, funktionieren würde:

1. Während des Authentifizierungsvorgangs Ihrer App oder zu einem späteren Zeitpunkt können Sie das Authentifizierungstoken des Nutzers im Block Store speichern, um es später abzurufen.
2. Das Token wird lokal gespeichert und kann auch in der Cloud gesichert werden. Wenn möglich, wird es dabei end-to-end-verschlüsselt.
3. Daten werden übertragen, wenn der Nutzer auf einem neuen Gerät einen Wiederherstellungsvorgang startet.
4. Wenn der Nutzer Ihre App während des Wiederherstellungsvorgangs wiederherstellt, kann Ihre App das gespeicherte Token auf dem neuen Gerät aus dem Block Store abrufen.

Token wird gespeichert

Wenn sich ein Nutzer in Ihrer App anmeldet, können Sie das Authentifizierungstoken, das Sie für diesen Nutzer generieren, im Block Store speichern. Sie können dieses Token mit einem eindeutigen Schlüsselpaarwert speichern, der maximal 4 KB pro Eintrag umfasst. Rufen Sie setBytes() und setKey() für eine Instanz von StoreBytesData.Builder auf, um das Token zu speichern und die Anmeldedaten des Nutzers auf dem Quellgerät zu speichern. Nachdem Sie das Token mit Block Store gespeichert haben, wird es verschlüsselt und lokal auf dem Gerät gespeichert.

Das folgende Beispiel zeigt, wie das Authentifizierungstoken auf dem lokalen Gerät gespeichert wird:

Java

  BlockstoreClient client = Blockstore.getClient(this);
  byte[] bytes1 = new byte[] { 1, 2, 3, 4 };  // Store one data block.
  String key1 = "com.example.app.key1";
  StoreBytesData storeRequest1 = StoreBytesData.Builder()
          .setBytes(bytes1)
          // Call this method to set the key value pair the data should be associated with.
          .setKeys(Arrays.asList(key1))
          .build();
  client.storeBytes(storeRequest1)
    .addOnSuccessListener(result -> Log.d(TAG, "stored " + result + " bytes"))
    .addOnFailureListener(e -> Log.e(TAG, "Failed to store bytes", e));

Kotlin

  val client = Blockstore.getClient(this)

  val bytes1 = byteArrayOf(1, 2, 3, 4) // Store one data block.
  val key1 = "com.example.app.key1"
  val storeRequest1 = StoreBytesData.Builder()
    .setBytes(bytes1) // Call this method to set the key value with which the data should be associated with.
    .setKeys(Arrays.asList(key1))
    .build()
  client.storeBytes(storeRequest1)
    .addOnSuccessListener { result: Int ->
      Log.d(TAG,
            "Stored $result bytes")
    }
    .addOnFailureListener { e ->
      Log.e(TAG, "Failed to store bytes", e)
    }

Hinweis Zuvor gespeicherte Byte ohne Schlüssel? Wenn Sie die StoreBytes() API bereits zum Speichern Ihrer Daten verwendet haben, sollten Sie Ihre Tokens mit einem Schlüssel speichern. Daten, die zuvor mit „StoreBytes“ gespeichert wurden, werden jetzt mit dem Schlüssel BlockstoreClient.DEFAULT_BYTES_DATA_KEY gespeichert.

Standardtoken verwenden

Für Daten, die mit „StoreBytes“ ohne Schlüssel gespeichert werden, wird der Standardschlüssel BlockstoreClient.DEFAULT_BYTES_DATA_KEY verwendet.

Java

  BlockstoreClient client = Blockstore.getClient(this);
  // The default key BlockstoreClient.DEFAULT_BYTES_DATA_KEY.
  byte[] bytes = new byte[] { 9, 10 };
  StoreBytesData storeRequest = StoreBytesData.Builder()
          .setBytes(bytes)
          .build();
  client.storeBytes(storeRequest)
    .addOnSuccessListener(result -> Log.d(TAG, "stored " + result + " bytes"))
    .addOnFailureListener(e -> Log.e(TAG, "Failed to store bytes", e));

Kotlin

  val client = Blockstore.getClient(this);
  // the default key BlockstoreClient.DEFAULT_BYTES_DATA_KEY.
  val bytes = byteArrayOf(1, 2, 3, 4)
  val storeRequest = StoreBytesData.Builder()
    .setBytes(bytes)
    .build();
  client.storeBytes(storeRequest)
    .addOnSuccessListener { result: Int ->
      Log.d(TAG,
            "stored $result bytes")
    }
    .addOnFailureListener { e ->
      Log.e(TAG, "Failed to store bytes", e)
    }

Hinweis :Auf dem Gerät werden Block Store-Daten im lokalen privaten Datenverzeichnis der Google Play-Dienste gespeichert. Keine anderen Apps können direkt auf die Datendatei zugreifen. Sie können nur über die retrieveBytes() API auf Block Store-Daten zugreifen und eine App kann nur Daten abrufen, die von ihr selbst gespeichert wurden. Google Play-Dienste prüfen sowohl den Paketnamen als auch die Signatur.

Token abrufen

Wenn ein Nutzer später auf einem neuen Gerät den Wiederherstellungsvorgang durchläuft, werden die Google Play-Dienste zuerst den Nutzer authentifizieren und dann Ihre Block Store-Daten abrufen. Der Nutzer hat bereits im Rahmen des Wiederherstellungsvorgangs zugestimmt, dass Ihre App-Daten wiederhergestellt werden. Daher sind keine zusätzlichen Einwilligungen erforderlich. Wenn der Nutzer Ihre App öffnet, können Sie Ihr Token von Block Store anfordern, indem Sie retrieveBytes() aufrufen. Das abgerufene Token kann dann verwendet werden, um den Nutzer auf dem neuen Gerät angemeldet zu lassen.

Im folgenden Beispiel wird gezeigt, wie Sie mehrere Tokens basierend auf bestimmten Schlüsseln abrufen.

Java

BlockstoreClient client = Blockstore.getClient(this);

// Retrieve data associated with certain keys.
String key1 = "com.example.app.key1";
String key2 = "com.example.app.key2";
String key3 = BlockstoreClient.DEFAULT_BYTES_DATA_KEY; // Used to retrieve data stored without a key

List requestedKeys = Arrays.asList(key1, key2, key3); // Add keys to array
RetrieveBytesRequest retrieveRequest = new RetrieveBytesRequest.Builder()
    .setKeys(requestedKeys)
    .build();

client.retrieveBytes(retrieveRequest)
    .addOnSuccessListener(
        result -> {
          Map<String, BlockstoreData> blockstoreDataMap = result.getBlockstoreDataMap();
          for (Map.Entry<String, BlockstoreData> entry : blockstoreDataMap.entrySet()) {
            Log.d(TAG, String.format(
                "Retrieved bytes %s associated with key %s.",
                new String(entry.getValue().getBytes()), entry.getKey()));
          }
        })
    .addOnFailureListener(e -> Log.e(TAG, "Failed to store bytes", e));

Kotlin

val client = Blockstore.getClient(this)

// Retrieve data associated with certain keys.
val key1 = "com.example.app.key1"
val key2 = "com.example.app.key2"
val key3 = BlockstoreClient.DEFAULT_BYTES_DATA_KEY // Used to retrieve data stored without a key

val requestedKeys = Arrays.asList(key1, key2, key3) // Add keys to array

val retrieveRequest = RetrieveBytesRequest.Builder()
  .setKeys(requestedKeys)
  .build()

client.retrieveBytes(retrieveRequest)
  .addOnSuccessListener { result: RetrieveBytesResponse ->
    val blockstoreDataMap =
      result.blockstoreDataMap
    for ((key, value) in blockstoreDataMap) {
      Log.d(ContentValues.TAG, String.format(
        "Retrieved bytes %s associated with key %s.",
        String(value.bytes), key))
    }
  }
  .addOnFailureListener { e: Exception? ->
    Log.e(ContentValues.TAG,
          "Failed to store bytes",
          e)
  }

Alle Tokens abrufen.

Unten sehen Sie ein Beispiel dafür, wie Sie alle in BlockStore gespeicherten Tokens abrufen.

Java

BlockstoreClient client = Blockstore.getClient(this)

// Retrieve all data.
RetrieveBytesRequest retrieveRequest = new RetrieveBytesRequest.Builder()
    .setRetrieveAll(true)
    .build();

client.retrieveBytes(retrieveRequest)
    .addOnSuccessListener(
        result -> {
          Map<String, BlockstoreData> blockstoreDataMap = result.getBlockstoreDataMap();
          for (Map.Entry<String, BlockstoreData> entry : blockstoreDataMap.entrySet()) {
            Log.d(TAG, String.format(
                "Retrieved bytes %s associated with key %s.",
                new String(entry.getValue().getBytes()), entry.getKey()));
          }
        })
    .addOnFailureListener(e -> Log.e(TAG, "Failed to store bytes", e));

Kotlin

val client = Blockstore.getClient(this)

val retrieveRequest = RetrieveBytesRequest.Builder()
  .setRetrieveAll(true)
  .build()

client.retrieveBytes(retrieveRequest)
  .addOnSuccessListener { result: RetrieveBytesResponse ->
    val blockstoreDataMap =
      result.blockstoreDataMap
    for ((key, value) in blockstoreDataMap) {
      Log.d(ContentValues.TAG, String.format(
        "Retrieved bytes %s associated with key %s.",
        String(value.bytes), key))
    }
  }
  .addOnFailureListener { e: Exception? ->
    Log.e(ContentValues.TAG,
          "Failed to store bytes",
          e)
  }

Hinweis Veraltung von retrieveBytes() retrieveBytes() wurde eingestellt. Zum Abrufen von Byte kann der Schlüssel BlockstoreClient.DEFAULT_BYTES_DATA_KEY in der RetrieveBytesRequest-Instanz verwendet werden, um Ihre gespeicherten Daten abzurufen.

Unten sehen Sie ein Beispiel dafür, wie Sie den Standardschlüssel abrufen.

Java

BlockStoreClient client = Blockstore.getClient(this);
RetrieveBytesRequest retrieveRequest = new RetrieveBytesRequest.Builder()
    .setKeys(Arrays.asList(BlockstoreClient.DEFAULT_BYTES_DATA_KEY))
    .build();
client.retrieveBytes(retrieveRequest);

Kotlin

val client = Blockstore.getClient(this)

val retrieveRequest = RetrieveBytesRequest.Builder()
  .setKeys(Arrays.asList(BlockstoreClient.DEFAULT_BYTES_DATA_KEY))
  .build()
client.retrieveBytes(retrieveRequest)

Tokens löschen

Das Löschen von Tokens aus BlockStore kann aus folgenden Gründen erforderlich sein:

• Der Nutzer durchläuft den Abmeldevorgang.
• Der Token wurde widerrufen oder ist ungültig.

Ähnlich wie beim Abrufen von Tokens können Sie angeben, welche Tokens gelöscht werden müssen, indem Sie ein Array von Schlüsseln festlegen, die gelöscht werden müssen.

Im folgenden Beispiel wird gezeigt, wie bestimmte Schlüssel gelöscht werden:

Java

BlockstoreClient client = Blockstore.getClient(this);

// Delete data associated with certain keys.
String key1 = "com.example.app.key1";
String key2 = "com.example.app.key2";
String key3 = BlockstoreClient.DEFAULT_BYTES_DATA_KEY; // Used to delete data stored without key

List requestedKeys = Arrays.asList(key1, key2, key3) // Add keys to array
DeleteBytesRequest deleteRequest = new DeleteBytesRequest.Builder()
      .setKeys(requestedKeys)
      .build();
client.deleteBytes(deleteRequest)

Kotlin

val client = Blockstore.getClient(this)

// Retrieve data associated with certain keys.
val key1 = "com.example.app.key1"
val key2 = "com.example.app.key2"
val key3 = BlockstoreClient.DEFAULT_BYTES_DATA_KEY // Used to retrieve data stored without a key

val requestedKeys = Arrays.asList(key1, key2, key3) // Add keys to array

val retrieveRequest = DeleteBytesRequest.Builder()
      .setKeys(requestedKeys)
      .build()

client.deleteBytes(retrieveRequest)

Alle Tokens löschen

Das folgende Beispiel zeigt, wie alle derzeit in BlockStore gespeicherten Tokens gelöscht werden:

Java

// Delete all data.
DeleteBytesRequest deleteAllRequest = new DeleteBytesRequest.Builder()
      .setDeleteAll(true)
      .build();
client.deleteBytes(deleteAllRequest)
.addOnSuccessListener(result -> Log.d(TAG, "Any data found and deleted? " + result));

Kotlin

  val deleteAllRequest = DeleteBytesRequest.Builder()
  .setDeleteAll(true)
  .build()
retrieve bytes, the key BlockstoreClient.DEFAULT_BYTES_DATA_KEY can be used
in the RetrieveBytesRequest instance in order to get your saved data

The following example shows how to retrieve the default key.

Java

End-to-end encryption

In order for end-to-end encryption to be made available, the device must be running Android 9 or higher, and the user must have set a screen lock (PIN, pattern, or password) for their device. You can verify if encryption will be available on the device by calling isEndToEndEncryptionAvailable().

The following sample shows how to verify if encryption will be available during cloud backup:

client.isEndToEndEncryptionAvailable()
        .addOnSuccessListener { result ->
          Log.d(TAG, "Will Block Store cloud backup be end-to-end encrypted? $result")
        }

Hinweis :Es wird empfohlen, vor dem Aktivieren der Cloud-Sicherung zu prüfen, ob die Ende-zu-Ende-Verschlüsselung verfügbar ist.

Cloud-Sicherung aktivieren

Um die Cloud-Sicherung zu aktivieren, fügen Sie die Methode setShouldBackupToCloud() Ihrem StoreBytesData-Objekt hinzu. Block Store sichert die gespeicherten Byte regelmäßig in der Cloud, wenn setShouldBackupToCloud() auf „true“ gesetzt ist.

Das folgende Beispiel zeigt, wie Sie die Cloud-Sicherung nur dann aktivieren, wenn sie Ende-zu-Ende-verschlüsselt ist:

val client = Blockstore.getClient(this)
val storeBytesDataBuilder = StoreBytesData.Builder()
        .setBytes(/* BYTE_ARRAY */)

client.isEndToEndEncryptionAvailable()
        .addOnSuccessListener { isE2EEAvailable ->
          if (isE2EEAvailable) {
            storeBytesDataBuilder.setShouldBackupToCloud(true)
            Log.d(TAG, "E2EE is available, enable backing up bytes to the cloud.")

            client.storeBytes(storeBytesDataBuilder.build())
                .addOnSuccessListener { result ->
                  Log.d(TAG, "stored: ${result.getBytesStored()}")
                }.addOnFailureListener { e ->
                  Log.e(TAG, “Failed to store bytes”, e)
                }
          } else {
            Log.d(TAG, "E2EE is not available, only store bytes for D2D restore.")
          }
        }

Hinweis :Wenn storeBytes mit shouldBackupToCloud nicht festgelegt oder als falsch festgelegt wird, werden die zuvor in der Cloud gesicherten Bytes dieses Geräts bei der nächsten regelmäßigen Synchronisierung aus der Cloud gelöscht.

Testen

Verwenden Sie die folgenden Methoden während der Entwicklung, um die Wiederherstellungsabläufe zu testen.

Deinstallation/Neuinstallation auf demselben Gerät

Wenn der Nutzer Sicherungsdienste aktiviert (Einstellungen > Google > Sicherung), bleiben Block Store-Daten bei der Deinstallation/Neuinstallation der App erhalten.

So können Sie das testen:

1. Binden Sie die Block Store API in Ihre Test-App ein.
2. Rufen Sie die Block Store API mit der Test-App auf, um Ihre Daten zu speichern.
3. Deinstallieren Sie Ihre Test-App und installieren Sie sie dann auf demselben Gerät neu.
4. Rufen Sie die Block Store API mit der Test-App auf, um Ihre Daten abzurufen.
5. Prüfen Sie, ob die abgerufenen Bytes mit den vor der Deinstallation gespeicherten Bytes übereinstimmen.

Hinweis :Da für das Testen der geräteübergreifenden Wiederherstellung mehr Schritte erforderlich sind, empfiehlt es sich, zuerst die Integration Ihrer App in die Block Store API anhand des Deinstallations-/Neuinstallationsszenarios zu prüfen.

Gerät-zu-Gerät

In den meisten Fällen ist dazu ein Zurücksetzen des Zielgeräts auf die Werkseinstellungen erforderlich. Anschließend können Sie den Android-Wiederherstellungsvorgang über WLAN oder die Google-Kabelwiederherstellung (für unterstützte Geräte) starten.

Hinweis :Wenn es sich bei dem Zielgerät um ein Samsung Galaxy handelt, können Sie den Wiederherstellungsvorgang starten, indem Sie Smart Switch außerhalb der Einrichtung starten.

Wiederherstellung aus der Cloud

1. Binden Sie die Block Store API in Ihre Test-App ein. Die Test-App muss im Play Store eingereicht werden.
2. Rufen Sie auf dem Quellgerät mit der Test-App die Block Store API auf, um Ihre Daten zu speichern. Setzen Sie shouldBackUpToCloud auf true.
3. Auf Geräten mit Android O und höher können Sie manuell ein Cloud-Backup für Block Store auslösen. Gehen Sie dazu zu Einstellungen > Google > Backup und klicken Sie auf die Schaltfläche „Jetzt sichern“.
   1. So prüfen Sie, ob die Block Store-Cloud-Sicherung erfolgreich war:
      1. Suchen Sie nach Abschluss der Sicherung nach Logzeilen mit dem Tag „CloudSyncBpTkSvc“.
      2. Sie sollten Zeilen wie diese sehen: „......, CloudSyncBpTkSvc: sync result: SUCCESS, ..., uploaded size: XXX bytes ...“
   2. Nach einer Block Store-Cloud-Sicherung gibt es eine 5-minütige „Abkühlphase“. Wenn Sie innerhalb dieser 5 Minuten auf die Schaltfläche „Jetzt sichern“ klicken, wird keine weitere Block Storage-Sicherung in der Cloud ausgelöst.
4. Setze das Zielgerät auf die Werkseinstellungen zurück und führe eine Wiederherstellung aus der Cloud durch. Wählen Sie aus, um Ihre Test-App während der Wiederherstellung wiederherzustellen. Weitere Informationen zu Cloud-Wiederherstellungsvorgängen finden Sie unter Unterstützte Cloud-Wiederherstellungsvorgänge.
5. Rufen Sie auf dem Zielgerät mit der Test-App die Block Store API auf, um Ihre Daten abzurufen.
6. Prüfen Sie, ob die abgerufenen Bytes mit den auf dem Quellgerät gespeicherten Bytes übereinstimmen.

Geräteanforderungen

Ende-zu-Ende-Verschlüsselung

• Die Ende-zu-Ende-Verschlüsselung wird auf Geräten mit Android 9 (API 29) und höher unterstützt.
• Auf dem Gerät muss eine Displaysperre mit einer PIN, einem Muster oder einem Passwort eingerichtet sein, damit die Ende-zu-Ende-Verschlüsselung aktiviert und die Daten des Nutzers korrekt verschlüsselt werden können.

Hinweis :isEndtoEndEncryptionAvailable() gibt „false“ zurück, wenn eine dieser Bedingungen nicht erfüllt ist.

Ablauf der Wiederherstellung von Gerät zu Gerät

Für die Wiederherstellung von Gerät zu Gerät benötigen Sie ein Quellgerät und ein Zielgerät. Dies sind die beiden Geräte, zwischen denen Daten übertragen werden.

Auf Quellgeräten muss Android 6 (API 23) oder höher installiert sein, damit Backups erstellt werden können.

Zielgeräte mit Android 9 (API 29) und höher müssen die Möglichkeit zur Wiederherstellung bieten.

Weitere Informationen zum Wiederherstellungsvorgang von Gerät zu Gerät

Ablauf für das Speichern und Wiederherstellen von Inhalten in der Cloud

Für das Sichern und Wiederherstellen in der Cloud sind ein Quellgerät und ein Zielgerät erforderlich.

Auf Quellgeräten muss Android 6 (API 23) oder höher installiert sein, damit Backups erstellt werden können.

Zielgeräte werden je nach Hersteller unterstützt. Auf Pixel-Geräten kann diese Funktion ab Android 9 (API 29) verwendet werden. Auf allen anderen Geräten muss Android 12 (API 31) oder höher installiert sein.