Bloquear tienda

Nota: Para obtener una experiencia del usuario actualizada y otras mejoras, considera usar claves de acceso con el Administrador de credenciales en su lugar.

Muchos usuarios aún administran sus propias credenciales cuando configuran un dispositivo Android nuevo. Este proceso manual puede volverse difícil y, a menudo, genera una experiencia del usuario deficiente. La API de Block Store, una biblioteca con la tecnología de los Servicios de Google Play, busca resolver esto proporcionando una forma para que las apps guarden credenciales de usuario sin la complejidad o 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 inicias tu app por primera vez en el dispositivo nuevo.

Los beneficios de usar Block Store son 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.

Nota: El uso de Block Store no limita el tipo de credenciales que se pueden usar para el usuario. Los usuarios pueden acceder con su nombre de usuario y contraseña, su Cuenta de Google o cualquier otro proveedor de identidad federada, y Block Store sigue funcionando.

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 de 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.2.0'
}

Cómo funciona

Block Store permite a los desarrolladores guardar y restablecer arrays de hasta 16 bytes. Esto te permite guardar información importante relacionada con la sesión de usuario actual y ofrece la flexibilidad de guardarla como quieras. Estos datos se pueden encriptar de extremo a extremo, y la infraestructura que admite Block Store se basa en la infraestructura de copias de seguridad y restablecimientos.

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

1. Durante el flujo de autenticación de tu app o en cualquier momento posterior, puedes almacenar el token de autenticación del usuario en Block Store para recuperarlo más tarde.
2. El token se almacenará de manera local y también se podrá crear una copia de seguridad en la nube de extremo a extremo encriptado 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 podrá 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 usando un valor único de par de claves 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 a fin de 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:

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

¿Bytes ya almacenados sin clave?

Si ya usaste la API de StoreBytes() para guardar tus datos, te recomendamos que comiences a guardar tus tokens con una clave. Los datos previamente guardados con StoreBytes ahora se guardan con la clave BlockstoreClient.DEFAULT_BYTES_DATA_KEY.

Usar token predeterminado

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

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

¿Cómo se almacenan los datos en el dispositivo y quién puede acceder a ellos?

En el dispositivo, los datos de BlockStore se almacenan en el directorio local de datos privados de los Servicios de Google Play. Ninguna otra app puede acceder directamente al archivo de datos. Solo pueden acceder a los datos de BlockStore a través de la API de retrieveBytes(), y una app solo puede recuperar datos almacenados por sí misma. Los Servicios de Google Play verifican el nombre y la firma del paquete.

Cómo recuperar el token

Más adelante, cuando un usuario complete el flujo de restablecimiento en un dispositivo nuevo, los Servicios de Google Play primero lo verificarán y, luego, recuperarán tus 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 abra tu app, puedes llamar a retrieveBytes() para solicitar tu token de Block Store. El token recuperado se puede usar para mantener al usuario conectado en el dispositivo nuevo.

En el siguiente ejemplo, se muestra cómo recuperar varios tokens en función de claves específicas.

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 blockstoreDataMap = result.getBlockstoreDataMap();
          for (Map.Entry 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)
  }

Recuperando todos los tokens

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

Java

BlockstoreClient client = Blockstore.getClient(this)

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

client.retrieveBytes(retrieveRequest)
    .addOnSuccessListener(
        result -> {
          Map blockstoreDataMap = result.getBlockstoreDataMap();
          for (Map.Entry 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)
  }

Baja de bytes()

Se dio de baja retrieveBytes(). Para recuperar bytes, se puede usar la clave BlockstoreClient.DEFAULT_BYTES_DATA_KEY en la instancia de RetrieveBytesRequest a fin de obtener los datos guardados.

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

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)

Borra tokens

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

• El usuario sale del flujo de usuarios.
• 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 requieran eliminación.

A continuación, se muestra un ejemplo para borrar ciertas claves.

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)

Borrar todos los tokens

En el siguiente ejemplo, se borran todos los tokens guardados actualmente en BlockStore:

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()
client.deleteBytes(deleteAllRequest)
  .addOnSuccessListener { result: Boolean ->
    Log.d(TAG,
          "Any data found and deleted? $result")
  }

Encriptación de extremo a extremo

Para que la encriptación de extremo a extremo esté disponible, el dispositivo debe ejecutar Android 9 o una versión posterior, y el usuario debe configurar un bloqueo de pantalla (PIN, patrón o contraseña) para su dispositivo. Para verificar si la encriptación estará disponible en el dispositivo, llama a isEndToEndEncryptionAvailable().

En el siguiente ejemplo, se muestra cómo verificar si la encriptación estará disponible durante la copia de seguridad en la nube:

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

Nota: Se recomienda verificar que la encriptación de extremo a extremo esté disponible antes de habilitar la copia de seguridad en la nube.

Habilitar 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. La función Block Store creará copias de seguridad en la nube de forma periódica para los bytes almacenados cuando setShouldBackupToCloud() se establezca como verdadero.

En el siguiente ejemplo, se muestra cómo habilitar la copia de seguridad en la nube solo cuando la copia de seguridad en la nube 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.")
          }
        }

Nota: Si se llama a storeBytes con shouldBackupToCloud unset o se establece como false, los bytes de este dispositivo que ya tengan una copia de seguridad en la nube se borrarán de la nube en la siguiente sincronización periódica.

Cómo realizar pruebas

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

Desinstalación y reinstalación en el mismo dispositivo

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

Puedes seguir estos pasos para hacer la prueba:

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

Nota: Como se requieren más pasos para probar el restablecimiento en varios dispositivos, te recomendamos que primero verifiques la integración de tu app a la API de BlockStore con el caso de desinstalación/reinstalación.

Dispositivo a dispositivo

En la mayoría de los casos, deberás restablecer la configuración de fábrica del dispositivo de destino. Luego, puedes ingresar al flujo de restablecimiento inalámbrico de Android o al restablecimiento de cables de Google (para dispositivos compatibles).

Nota: Si el dispositivo de destino es un Samsung Galaxy, puedes iniciar el flujo de restablecimiento iniciando Smart Switch fuera de la configuración.

Restablecimiento en la nube

1. Integra la API de Blockstore a tu app de prueba. La app de prueba debe enviarse a Play Store.
2. En el dispositivo de origen, usa la app de prueba a fin de invocar la API de Blockstore para almacenar tus datos, con shouldBackUpToCloud establecido en verdadero.
3. Para dispositivos con Android O y versiones posteriores, puedes activar manualmente una copia de seguridad en la nube de Store 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 Store se haya bloqueado, puedes hacer lo siguiente:
      1. Una vez que finalice la copia de seguridad, busca líneas de registro con la etiqueta “CloudSyncBpTkSvc”.
      2. Deberías ver líneas como estas: “......, 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 “refrigeración” de 5 minutos. Después de ese plazo, no se activará otra copia de seguridad en la nube de Block Store cuando hagas clic en el botón “Crear copia de seguridad ahora”.
4. Restablece la configuración de fábrica del dispositivo de destino y realiza un flujo de restablecimiento de la nube. Selecciona para restablecer tu app de prueba durante el flujo de restablecimiento. Si deseas 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 Blockstore a fin de 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.

Nota: isEndtoEndEncryptAvailable() mostrará el valor falso si no se cumple alguna de estas condiciones.

Flujo de restablecimiento de dispositivo a dispositivo

Para restaurar dispositivos entre dispositivos, necesitarás un dispositivo de origen y un dispositivo de destino. Estos serán los dos dispositivos que transferirán datos.

Para realizar copias de seguridad, los dispositivos de origen deben ejecutar Android 6 (nivel de API 23) y versiones posteriores.

Orienta los dispositivos a Android 9 (nivel de API 29) y versiones posteriores para que puedan restablecerse.

Aquí encontrarás más información sobre el flujo de restablecimiento de dispositivos a dispositivos.

Flujo de copia de seguridad y restablecimiento de Cloud

La copia de seguridad y el restablecimiento de Cloud requerirán un dispositivo de origen y un dispositivo de destino.

Para realizar copias de seguridad, los dispositivos de origen deben ejecutar Android 6 (nivel de API 23) y versiones posteriores.

Los dispositivos objetivo se admiten en función de sus proveedores. Los dispositivos Pixel pueden usar esta función desde Android 9 (nivel de API 29) y todos los demás dispositivos deben ejecutar Android 12 (nivel de API 31) o versiones posteriores.