Bloquear tienda

Muchos usuarios aún administran sus propias credenciales cuando configuran un dispositivo nuevo con Android. Este proceso manual puede ser desafiante y, a menudo, genera una experiencia del usuario deficiente. La API de Block Store, una biblioteca con tecnología de los Servicios de Google Play, busca resolver este problema proporcionando una forma para que las apps guarden las credenciales del usuario sin la complejidad ni el riesgo de seguridad asociados con el guardado de contraseñas del usuario.

La API de Block Store permite que tu app almacene datos que luego puede recuperar para volver a autenticar a los usuarios en un dispositivo nuevo. Esto ayuda a proporcionar una experiencia más fluida para el usuario, ya que no necesita ver una pantalla de acceso cuando inicia tu app por primera vez en el dispositivo nuevo.

Entre los beneficios de usar Block Store, se incluyen los siguientes:

• Solución de almacenamiento de credenciales encriptadas para desarrolladores. Las credenciales están encriptadas de extremo a extremo cuando es posible.
• Guarda tokens en lugar de nombres de usuario y contraseñas.
• Elimina los inconvenientes de los flujos de acceso.
• Evita que los usuarios tengan que administrar contraseñas complejas.
• Google verifica la identidad del usuario.

Antes de comenzar

Para preparar tu app, completa los pasos que se indican en las siguientes secciones.

Cómo configurar tu app

En el archivo build.gradle a nivel de proyecto, incluye el repositorio Maven de Google en las secciones buildscript y allprojects:

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

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

Agrega la dependencia de los Servicios de Google Play para la API de Block Store al archivo de compilación de Gradle de tu módulo, que suele ser app/build.gradle:

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

Cómo funciona

Block Store permite a los desarrolladores guardar y restablecer hasta 16 arreglos de bytes. Esto te permite guardar información importante sobre la sesión del usuario actual y te ofrece la flexibilidad de guardar esta información como desees. Estos datos se pueden encriptar de extremo a extremo, y la infraestructura que admite Block Store se compila sobre la infraestructura de copia de seguridad y restablecimiento.

En esta guía, se abordará el caso de uso de guardar el token de un usuario en Block Store. En los siguientes pasos, se describe cómo funcionaría una app que usa Block Store:

1. Durante el flujo de autenticación de tu app o en cualquier momento después, puedes almacenar el token de autenticación del usuario en Block Store para recuperarlo más adelante.
2. El token se almacenará de forma local y también se podrá crear una copia de seguridad en la nube, encriptada de extremo a extremo cuando sea posible.
3. Los datos se transfieren cuando el usuario inicia un flujo de restablecimiento en un dispositivo nuevo.
4. Si el usuario restablece tu app durante el flujo de restablecimiento, esta puede recuperar el token guardado de Block Store en el dispositivo nuevo.

Cómo guardar el token

Cuando un usuario accede a tu app, puedes guardar el token de autenticación que generas para ese usuario en Block Store. Puedes almacenar este token con un valor de par de claves único que tenga un máximo de 4 KB por entrada. Para almacenar el token, llama a setBytes() y setKey() en una instancia de StoreBytesData.Builder para almacenar las credenciales del usuario en el dispositivo de origen. Después de guardar el token con Block Store, este se encripta y se almacena de forma local en el dispositivo.

En el siguiente ejemplo, se muestra cómo guardar el token de autenticación en el dispositivo local:

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

Usa el token predeterminado

Los datos guardados con StoreBytes sin una clave usan la clave predeterminada BlockstoreClient.DEFAULT_BYTES_DATA_KEY.

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

Cómo recuperar el token

Más adelante, cuando un usuario pasa por el flujo de restablecimiento en un dispositivo nuevo, los servicios de Google Play primero verifican al usuario y, luego, recuperan los datos de Block Store. El usuario ya aceptó restablecer los datos de tu app como parte del flujo de restablecimiento, por lo que no se requieren consentimientos adicionales. Cuando el usuario abre tu app, puedes solicitar tu token de Block Store llamando a retrieveBytes(). Luego, se puede usar el token recuperado para mantener al usuario en el dispositivo nuevo.

En el siguiente ejemplo, se muestra cómo recuperar varios tokens según claves específicas.

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

Recupera todos los tokens.

A continuación, se muestra un ejemplo de cómo recuperar todos los tokens guardados en BlockStore.

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

A continuación, se muestra un ejemplo de cómo recuperar la clave predeterminada.

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)

Cómo borrar tokens

Es posible que debas borrar tokens de BlockStore por los siguientes motivos:

• El usuario pasa por el flujo de salida del usuario.
• El token se revocó o no es válido.

Al igual que con la recuperación de tokens, puedes especificar qué tokens se deben borrar configurando un array de claves que se deben borrar.

En el siguiente ejemplo, se muestra cómo borrar ciertas claves:

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)

Borrar todos los tokens

En el siguiente ejemplo, se muestra cómo borrar todos los tokens que se guardaron en BlockStore:

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

Habilita la copia de seguridad en la nube

Para habilitar la copia de seguridad en la nube, agrega el método setShouldBackupToCloud() a tu objeto StoreBytesData. Block Store creará copias de seguridad de forma periódica en la nube de los bytes almacenados cuando setShouldBackupToCloud() esté configurado como verdadero.

En el siguiente ejemplo, se muestra cómo habilitar la copia de seguridad en la nube solo cuando está encriptada de extremo a extremo:

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

Cómo realizar la prueba

Usa los siguientes métodos durante el desarrollo para probar los flujos de restablecimiento.

Desinstalar y volver a instalar en el mismo dispositivo

Si el usuario habilita los servicios de copia de seguridad (se puede verificar en Configuración > Google > Copia de seguridad), los datos de Block Store se conservan durante la desinstalación y reinstalación de la app.

Puedes seguir estos pasos para probar lo siguiente:

1. Integra la API de Block Store a tu app de prueba.
2. Usa la app de prueba para invocar la API de Block Store y almacenar tus datos.
3. Desinstala la app de prueba y, luego, vuelve a instalarla en el mismo dispositivo.
4. Usa la app de prueba para invocar la API de Block Store y recuperar tus datos.
5. Verifica que los bytes recuperados sean los mismos que se almacenaron antes de la desinstalación.

De dispositivo a dispositivo

En la mayoría de los casos, esto requerirá que se restablezca la configuración de fábrica del dispositivo de destino. Luego, puedes ingresar al flujo de restablecimiento inalámbrico de Android o al restablecimiento con cable de Google (para dispositivos compatibles).

Restablecimiento en la nube

1. Integra la API de Block Store a tu app de prueba. La app de prueba se debe enviar a Play Store.
2. En el dispositivo de origen, usa la app de prueba para invocar la API de Block Store y almacenar tus datos, con shouldBackUpToCloud establecido en true.
3. En dispositivos con Android O y versiones posteriores, puedes activar manualmente una copia de seguridad en la nube de Block Store: ve a Configuración > Google > Copia de seguridad y haz clic en el botón "Crear copia de seguridad ahora".
   1. Para verificar que la copia de seguridad en la nube de Block Store se realizó correctamente, puedes hacer lo siguiente:
      1. Cuando finalice la copia de seguridad, busca líneas de registro con la etiqueta “CloudSyncBpTkSvc”.
      2. Deberías ver líneas como las siguientes: “......, CloudSyncBpTkSvc: sync result: SUCCESS, ..., uploaded size: XXX bytes ...”
   2. Después de una copia de seguridad en la nube de Block Store, hay un período de “inactividad” de 5 minutos. Durante esos 5 minutos, hacer clic en el botón “Crear copia de seguridad ahora” no activará otra copia de seguridad en la nube de Block Store.
4. Restablece la configuración de fábrica del dispositivo de destino y sigue un flujo de restablecimiento en la nube. Selecciona para restablecer tu app de prueba durante el flujo de restablecimiento. Para obtener más información sobre los flujos de restablecimiento de la nube, consulta Flujos de restablecimiento de la nube compatibles.
5. En el dispositivo de destino, usa la app de prueba para invocar la API de Block Store y recuperar tus datos.
6. Verifica que los bytes recuperados sean los mismos que se almacenaron en el dispositivo de origen.

Requisitos del dispositivo

Encriptación de extremo a extremo

• La encriptación de extremo a extremo es compatible con dispositivos que ejecutan Android 9 (nivel de API 29) y versiones posteriores.
• El dispositivo debe tener un bloqueo de pantalla configurado con un PIN, un patrón o una contraseña para que se habilite la encriptación de extremo a extremo y se encripten correctamente los datos del usuario.

Flujo de restablecimiento de dispositivo a dispositivo

Para restablecer datos de un dispositivo a otro, deberás tener un dispositivo de origen y uno de destino. Estos serán los dos dispositivos que transferirán datos.

Los dispositivos fuente deben ejecutar Android 6 (nivel de API 23) y versiones posteriores para crear copias de seguridad.

Orienta los dispositivos a Android 9 (nivel de API 29) y versiones posteriores para poder realizar el restablecimiento.

Obtén más información sobre el flujo de restablecimiento de dispositivo a dispositivo aquí.

Flujo de copia de seguridad y restablecimiento en la nube

La copia de seguridad y el restablecimiento en la nube requerirán un dispositivo de origen y uno de destino.

Los dispositivos fuente deben ejecutar Android 6 (nivel de API 23) y versiones posteriores para crear copias de seguridad.

Los dispositivos Target son compatibles según sus proveedores. Los dispositivos Pixel pueden usar esta función a partir de Android 9 (nivel de API 29), y todos los demás dispositivos deben ejecutar Android 12 (nivel de API 31) o versiones posteriores.