Blockhaus

Viele Nutzer verwalten ihre Anmeldedaten immer noch selbst, wenn sie ein neues Android-Gerät einrichten. Dieser manuelle Prozess kann schwierig sein und führt oft zu einer schlechten Nutzererfahrung. Die Block Store API, eine Bibliothek, die von Google Play-Diensten unterstützt wird, soll dieses Problem lösen. Sie bietet Apps eine Möglichkeit, Anmeldedaten von Nutzern zu speichern, ohne die Komplexität oder das Sicherheitsrisiko, 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. Das sorgt für eine reibungslosere Nutzererfahrung, da Nutzer beim ersten Starten Ihrer App auf dem neuen Gerät keinen Anmeldebildschirm sehen.

Die Vorteile der Verwendung von Block Store sind:

• Verschlüsselter Anmeldedatenspeicher für Entwickler Anmeldedaten werden nach Möglichkeit Ende-zu-Ende-verschlüsselt.
• Tokens anstelle von Nutzernamen und Passwörtern speichern
• Reibungslose Anmeldevorgänge
• Nutzer müssen keine komplexen Passwörter verwalten.
• Google überprüft die Identität des Nutzers.

Hinweis

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

Eigene App konfigurieren

Fügen Sie in der Datei build.gradle auf Projektebene in den Bereichen buildscript und allprojects das Maven-Repository Google's ein:

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

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

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

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 diese Informationen flexibel speichern. Diese Daten können Ende-zu-Ende-verschlüsselt 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 eines Nutzertokens in Block Store behandelt. Die folgenden Schritte beschreiben, wie eine App mit Block Store funktioniert:

1. Während des Authentifizierungsvorgangs Ihrer App oder jederzeit danach können Sie das Authentifizierungstoken des Nutzers in Block Store speichern, um es später abzurufen.
2. Das Token wird lokal gespeichert und kann nach Möglichkeit auch Ende-zu-Ende-verschlüsselt in der Cloud gesichert werden.
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 Block Store abrufen.

Token speichern

Wenn sich ein Nutzer in Ihrer App anmeldet, können Sie das Authentifizierungstoken, das Sie für diesen Nutzer generieren, in Block Store speichern. Sie können dieses Token mit einem eindeutigen Schlüssel-Wert-Paar speichern, das maximal 4 KB pro Eintrag umfasst. Rufen Sie zum Speichern des Tokens setBytes() und setKey() für eine Instanz von StoreBytesData.Builder auf, um die Anmeldedaten des Nutzers auf dem Quell gerä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 Sie das Authentifizierungstoken auf dem lokalen Gerät speichern:

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

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

Standardtoken verwenden

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

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

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

Token abrufen

Wenn ein Nutzer später auf einem neuen Gerät den Wiederherstellungsvorgang durchführt, überprüft Google Play-Dienste zuerst den Nutzer und ruft dann Ihre Block Store-Daten ab. Der Nutzer hat bereits im Rahmen des Wiederherstellungsvorgangs zugestimmt, dass Ihre App-Daten wiederhergestellt werden. Daher sind keine weiteren Einwilligungen erforderlich. Wenn der Nutzer Ihre App öffnet, können Sie Ihr Token aus Block Store anfordern, indem Sie retrieveBytes() aufrufen. Mit dem abgerufenen Token kann der Nutzer auf dem neuen Gerät angemeldet bleiben.

Das folgende Beispiel zeigt, wie Sie mehrere Tokens basierend auf bestimmten Schlüsseln abrufen.

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

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

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

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

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

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

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

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 führt den Vorgang zum Abmelden aus.
• Das Token wurde widerrufen oder ist ungültig.

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

Das folgende Beispiel zeigt, wie Sie bestimmte Schlüssel löschen:

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)

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 Sie alle derzeit in BlockStore gespeicherten Tokens löschen:

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

  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.

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

Cloud-Sicherung aktivieren

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

Das folgende Beispiel zeigt, wie Sie die Cloud-Sicherung nur aktivieren, wenn die Cloud-Sicherung 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.")
          }
        }

Testen

Verwenden Sie während der Entwicklung die folgenden Methoden, um die Wiederherstellungsvorgänge zu testen.

Deinstallation/Neuinstallation auf demselben Gerät

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

So können Sie testen:

1. Binden Sie die Block Store API in Ihre Test-App ein.
2. Rufen Sie mit der Test-App die Block Store API 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 mit der Test-App die Block Store API auf, um Ihre Daten abzurufen.
5. Prüfen Sie, ob die abgerufenen Bytes mit den Bytes übereinstimmen, die vor der Deinstallation gespeichert wurden.

Geräteübergreifend

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 eine WLAN-Verbindung oder die Google-Wiederherstellung über ein Kabel (für unterstützte Geräte) starten.

Wiederherstellung aus der Cloud

1. Binden Sie die Block Store API in Ihre Test-App ein. Die Test-App muss im Google 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 eine Block Store-Cloud-Sicherung manuell auslösen: Gehen Sie zu Einstellungen > Google > Sicherung 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. Innerhalb dieser 5 Minuten wird durch Klicken auf die Schaltfläche „Jetzt sichern“ keine weitere Block Store-Cloud-Sicherung ausgelöst.
4. Setzen Sie das Zielgerät auf die Werkseinstellungen zurück und führen Sie einen Wiederherstellungsvorgang aus der Cloud durch. Wählen Sie aus, dass Ihre Test-App während des Wiederherstellungsvorgangs wiederhergestellt werden soll. Weitere Informationen zu Wiederherstellungsvorgängen aus der Cloud finden Sie unter Unterstützte Wiederherstellungsvorgänge aus der Cloud.
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 Bytes übereinstimmen, die auf dem Quellgerät gespeichert wurden.

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 werden kann und die Daten des Nutzers korrekt verschlüsselt werden.

Wiederherstellungsvorgang 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. Auf diesen beiden Geräten werden Daten übertragen.

Auf Quellgeräten muss Android 6 (API 23) und höher installiert sein, um eine Sicherung durchzuführen.

Auf Zielgeräten muss Android 9 (API 29) und höher installiert sein, um eine Wiederherstellung durchzuführen.

Weitere Informationen zum Wiederherstellungsvorgang von Gerät zu Gerät finden Sie hier.

Wiederherstellungsvorgang für Cloud-Sicherung

Für die Cloud-Sicherung und ‑Wiederherstellung sind ein Quellgerät und ein Zielgerät erforderlich.

Auf Quellgeräten muss Android 6 (API 23) und höher installiert sein, um eine Sicherung durchzuführen.

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