Bloquer le magasin

Remarque:Pour une expérience utilisateur améliorée et d'autres améliorations, envisagez plutôt d'utiliser des clés d'accès avec le Gestionnaire d'identifiants .

De nombreux utilisateurs gèrent toujours leurs propres identifiants lors de la configuration d'un nouvel appareil Android. Ce processus manuel peut s'avérer difficile et nuit souvent à l'expérience utilisateur. L'API Block Store, une bibliothèque fournie par les services Google Play, cherche à résoudre ce problème en permettant aux applications d'enregistrer les identifiants utilisateur sans la complexité ni les risques de sécurité associés à l'enregistrement des mots de passe.

L'API Block Store permet à votre application de stocker des données qu'elle peut récupérer ultérieurement pour authentifier à nouveau les utilisateurs sur un nouvel appareil. Cela permet d'offrir une expérience plus fluide à l'utilisateur, car il n'a pas besoin de voir un écran de connexion lorsqu'il lance votre application pour la première fois sur le nouvel appareil.

Les avantages de l'utilisation du Block Store sont les suivants:

• Solution de stockage chiffré des identifiants pour les développeurs Les identifiants sont chiffrés de bout en bout lorsque cela est possible.
• Enregistrez des jetons au lieu des noms d'utilisateur et des mots de passe.
• Éliminez les frictions liées aux processus de connexion.
• Évitez aux utilisateurs d'avoir à gérer des mots de passe complexes.
• Google valide l'identité de l'utilisateur.

Remarque :L'utilisation du Block Store ne limite pas l'utilisateur au type d'identifiants pouvant être utilisé. Les utilisateurs peuvent se connecter avec leur nom d'utilisateur et leur mot de passe, leur compte Google ou tout autre fournisseur d'identité fédérée. Le blocage du stockage continue de fonctionner.

Avant de commencer

Pour préparer votre application, procédez comme indiqué dans les sections suivantes.

Configurer votre application

Dans le fichier build.gradle au niveau du projet, incluez le dépôt Maven de Google dans les sections buildscript et allprojects:

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

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

Ajoutez la dépendance des services Google Play pour l'API Block Store au fichier de compilation Gradle de votre module, qui est généralement app/build.gradle:

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

Fonctionnement

Block Store permet aux développeurs d'enregistrer et de restaurer des tableaux allant jusqu'à 16 octets. Cela vous permet d'enregistrer des informations importantes concernant la session utilisateur en cours et vous offre la possibilité d'enregistrer ces informations comme vous le souhaitez. Ces données peuvent être chiffrées de bout en bout, et l'infrastructure compatible avec le Block Store repose sur l'infrastructure de sauvegarde et de restauration.

Ce guide aborde le cas d'utilisation de l'enregistrement d'un jeton utilisateur dans le Block Store. Les étapes suivantes décrivent le fonctionnement d'une application utilisant le Block Store:

1. Au cours du flux d'authentification de votre application ou à tout moment par la suite, vous pouvez stocker le jeton d'authentification de l'utilisateur dans le Block Store pour le récupérer ultérieurement.
2. Le jeton sera stocké localement et pourra également être sauvegardé dans le cloud, chiffré de bout en bout si possible.
3. Les données sont transférées lorsque l'utilisateur lance un processus de restauration sur un nouvel appareil.
4. Si l'utilisateur restaure votre application pendant le flux de restauration, celle-ci peut récupérer le jeton enregistré dans le Block Store sur le nouvel appareil.

Enregistrer le jeton

Lorsqu'un utilisateur se connecte à votre application, vous pouvez enregistrer le jeton d'authentification que vous générez pour cet utilisateur dans le Block Store. Vous pouvez stocker ce jeton en utilisant une valeur de paire de clés unique de 4 Ko maximum par entrée. Pour stocker le jeton, appelez setBytes() et setKey() sur une instance de StoreBytesData.Builder afin de stocker les identifiants de l'utilisateur sur l'appareil source. Une fois le jeton enregistré avec Block Store, il est chiffré et stocké localement sur l'appareil.

L'exemple suivant montre comment enregistrer le jeton d'authentification sur l'appareil 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)
    }

Octets stockés précédemment sans clé ?

Si vous avez déjà utilisé l'API StoreBytes() pour enregistrer vos données, nous vous recommandons de commencer à enregistrer vos jetons à l'aide d'une clé. Les données précédemment enregistrées à l'aide de StoreBytes sont maintenant enregistrées avec la clé BlockstoreClient.DEFAULT_BYTES_DATA_KEY.

Utiliser le jeton par défaut

Les données enregistrées à l'aide de StoreBytes sans clé utilisent la clé par défaut 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)
    }

Comment les données sont-elles stockées sur l'appareil et qui peut y accéder ?

Sur l'appareil, les données BlockStore sont stockées dans le répertoire local de données privées des services Google Play. Aucune autre application ne peut accéder directement au fichier de données. Elles ne peuvent accéder aux données BlockStore que via l'API retrieveBytes(), et une application ne peut récupérer que les données stockées seules. Les services Google Play vérifient le nom du package et la signature.

Récupérer le jeton

Par la suite, lorsqu'un utilisateur suit le flux de restauration sur un nouvel appareil, les services Google Play vérifient d'abord l'utilisateur, puis récupèrent vos données Block Store. L'utilisateur a déjà accepté de restaurer les données de votre application dans le cadre du flux de restauration. Aucune autorisation supplémentaire n'est donc requise. Lorsque l'utilisateur ouvre votre application, vous pouvez demander votre jeton dans le Block Store en appelant retrieveBytes(). Le jeton récupéré peut ensuite être utilisé pour maintenir l'utilisateur connecté sur le nouvel appareil.

L'exemple suivant montre comment récupérer plusieurs jetons en fonction de clés spécifiques.

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

Récupérer tous les jetons

Vous trouverez ci-dessous un exemple de récupération de tous les jetons enregistrés dans 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)
  }

Abandon de fetchBytes().

retrieveBytes() est désormais obsolète. Pour récupérer des octets, vous pouvez utiliser la clé BlockstoreClient.DEFAULT_BYTES_DATA_KEY dans l'instance RetrieveBytesRequest afin d'obtenir vos données enregistrées

Vous trouverez ci-dessous un exemple de récupération de la clé par défaut.

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)

Supprimer des jetons

Vous devrez peut-être supprimer des jetons du BlockStore pour les raisons suivantes:

• L'utilisateur passe par le flux utilisateur de déconnexion.
• Le jeton a été révoqué ou n'est pas valide.

Comme pour la récupération de jetons, vous pouvez spécifier les jetons à supprimer en définissant un tableau de clés à supprimer.

Vous trouverez ci-dessous un exemple de suppression de certaines clés.

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)

Supprimer tous les jetons

L'exemple ci-dessous supprime tous les jetons actuellement enregistrés dans 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")
  }

Chiffrement de bout en bout

Pour que le chiffrement de bout en bout soit disponible, l'appareil doit être équipé d'Android 9 ou version ultérieure, et l'utilisateur doit avoir défini un verrouillage de l'écran (code, schéma ou mot de passe) pour son appareil. Pour vérifier si le chiffrement est disponible sur l'appareil, appelez isEndToEndEncryptionAvailable().

L'exemple suivant montre comment vérifier si le chiffrement est disponible pendant la sauvegarde dans le cloud:

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

Remarque :Nous vous recommandons de vérifier que le chiffrement de bout en bout est disponible avant d'activer la sauvegarde dans le cloud.

Activer la sauvegarde dans le cloud

Pour activer la sauvegarde dans le cloud, ajoutez la méthode setShouldBackupToCloud() à votre objet StoreBytesData. Block Store sauvegarde régulièrement dans le cloud les octets stockés lorsque setShouldBackupToCloud() est défini sur "true".

L'exemple suivant montre comment activer la sauvegarde dans le cloud uniquement lorsque la sauvegarde dans le cloud est chiffrée de bout en bout:

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

Remarque :Si storeBytes est appelé avec shouldBackupToCloud non défini ou défini sur false, les octets de cet appareil précédemment sauvegardés dans le cloud seront supprimés du cloud lors de la prochaine synchronisation périodique.

Test

Utilisez les méthodes suivantes pendant le développement afin de tester les flux de restauration.

Désinstallation/Réinstallation sur le même appareil

Si l'utilisateur active les services de sauvegarde (vous pouvez cocher cette case sous Paramètres > Google > Sauvegarde), les données du Block Store sont conservées pendant la désinstallation/réinstallation de l'application.

Pour ce faire, procédez comme suit:

1. Intégrez l'API BlockStore à votre application de test.
2. Utilisez l'application de test pour appeler l'API BlockStore afin de stocker vos données.
3. Désinstallez votre application de test, puis réinstallez-la sur le même appareil.
4. Utilisez l'application de test pour appeler l'API BlockStore afin de récupérer vos données.
5. Vérifiez que les octets récupérés sont identiques à ceux stockés avant la désinstallation.

Remarque :Étant donné que le test de restauration multi-appareil nécessite plus d'étapes, nous vous recommandons de commencer par vérifier l'intégration de votre application à l'API BlockStore à l'aide du cas de désinstallation/réinstallation.

D'un appareil à un autre

Dans la plupart des cas, cela nécessite de rétablir la configuration d'usine de l'appareil cible. Vous pouvez ensuite accéder au flux de restauration sans fil Android ou à la restauration par câble Google (pour les appareils compatibles).

Remarque :Si l'appareil cible est un Samsung Galaxy, vous pouvez accéder au flux de restauration en lançant Smart Switch en dehors de la configuration.

Restauration dans le cloud

1. Intégrez l'API Blockstore à votre application de test. Celle-ci doit être envoyée au Play Store.
2. Sur l'appareil source, utilisez l'application de test pour appeler l'API Blockstore afin de stocker vos données, avec shouldBackUpToCloud défini sur "true".
3. Pour les appareils O et versions ultérieures, vous pouvez déclencher manuellement une sauvegarde dans le cloud du Block Store : accédez à Paramètres > Google > Sauvegarde, puis cliquez sur le bouton "Sauvegarder maintenant".
   1. Pour vérifier que la sauvegarde dans le cloud du Block Store a bien été effectuée, vous pouvez :
      1. Une fois la sauvegarde terminée, recherchez les lignes de journal comportant le tag "CloudSyncBpTkSvc".
      2. Des lignes comme celles-ci doivent s'afficher : "......, CloudSyncBpTkSvc: sync result: SUCCESS, ..., uploaded size: XXX bytes ..."
   2. Après une sauvegarde dans le cloud du Block Store, un délai d'attente de cinq minutes s'applique. Au cours de ces cinq minutes, le bouton "Sauvegarder maintenant" ne déclenchera pas une autre sauvegarde dans le cloud Block Store.
4. Rétablissez la configuration d'usine de l'appareil cible et suivez la procédure de restauration dans le cloud. Sélectionnez cette option pour restaurer votre application de test pendant le flux de restauration. Pour en savoir plus sur les flux de restauration dans le cloud, consultez la section Flux de restauration dans le cloud compatibles.
5. Sur l'appareil cible, utilisez l'application de test pour appeler l'API Blockstore afin de récupérer vos données.
6. Vérifiez que les octets récupérés sont identiques à ceux stockés dans l'appareil source.

Configuration d'appareil requise

Chiffrement de bout en bout

• Le chiffrement de bout en bout est compatible avec les appareils équipés d'Android 9 (niveau d'API 29) ou version ultérieure.
• Le verrouillage de l'écran de l'appareil doit être défini avec un code, un schéma ou un mot de passe pour que le chiffrement de bout en bout soit activé et que les données de l'utilisateur soient correctement chiffrées.

Remarque :isEndtoEndEncryptionAvailable() renvoie la valeur "false" si l'une de ces conditions n'est pas remplie.

Processus de restauration d'appareil à appareil

La restauration d'appareil à appareil nécessite que vous disposiez d'un appareil source et d'un appareil cible. Il s'agit des deux appareils qui transféreront les données.

Les appareils sources doivent être équipés d'Android 6 (API 23) ou version ultérieure pour pouvoir sauvegarder des données.

Ciblez les appareils équipés d'Android 9 (API 29) ou version ultérieure pour pouvoir effectuer une restauration.

Pour en savoir plus sur la procédure de restauration d'appareil à appareil, cliquez ici.

Flux de sauvegarde dans le cloud et de restauration

La sauvegarde dans le cloud et la restauration nécessitent un appareil source et un appareil cible.

Les appareils sources doivent être équipés d'Android 6 (API 23) ou version ultérieure pour pouvoir sauvegarder des données.

Les appareils cibles sont acceptés en fonction des fournisseurs. Les appareils Pixel peuvent utiliser cette fonctionnalité à partir d'Android 9 (API 29), et tous les autres appareils doivent être équipés d'Android 12 (API 31) ou version ultérieure.