Sklep blokowy

Wielu użytkowników nadal zarządza własnymi danymi logowania podczas konfigurowania nowego urządzenia z Androidem. Ten ręczny proces może być skomplikowany i często zmniejsza komfort korzystania z usługi. Block Store API to biblioteka oparta na usługach Google Play, która rozwiązuje ten problem, umożliwiając aplikacjom zapisywanie danych logowania użytkowników bez złożoności i bezpieczeństwa związanego z zapisywaniem haseł użytkowników.

Interfejs Block Store API umożliwia aplikacji przechowywanie danych, które może później pobierać w celu ponownego uwierzytelnienia użytkowników na nowym urządzeniu. Zwiększy to wygodę użytkowników, ponieważ przy pierwszym uruchomieniu aplikacji na nowym urządzeniu nie będzie musiał zobaczyć ekranu logowania.

Zalety korzystania ze sklepu Block Store to między innymi:

  • Rozwiązanie do przechowywania zaszyfrowanych danych logowania dla programistów. Dane logowania są w miarę możliwości w pełni szyfrowane.
  • Zapisuj tokeny zamiast nazw użytkownika i haseł.
  • Wyeliminuj ułatwienia logowania się.
  • Ułatw użytkownikom zarządzanie złożonymi hasłami.
  • Google weryfikuje tożsamość użytkownika.

Zanim zaczniesz

Aby przygotować aplikację, wykonaj czynności opisane w poniższych sekcjach.

Konfiguracja aplikacji

W sekcji buildscript i allprojects pliku build.gradle na poziomie projektu dodaj repozytorium Google Maven:

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

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

Dodaj zależność Usług Google Play do interfejsu Block Store API do pliku build.gradle modułu. Jest to zwykle app/build.gradle:

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

Jak to działa

Sklep blokowy umożliwia programistom zapisywanie i przywracanie tablic o rozmiarze do 16 bajtów. Dzięki temu możesz zapisać ważne informacje o bieżącej sesji użytkownika i w dowolny sposób je zapisać. Dane te mogą być w pełni szyfrowane, a infrastruktura obsługująca Block Store jest oparta na infrastrukturze tworzenia i przywracania kopii zapasowych.

W tym przewodniku opisano przypadek użycia dotyczący zapisywania tokena użytkownika w sklepie Block Store. Oto, jak będzie działać aplikacja korzystająca ze sklepu Block Store:

  1. Podczas procesu uwierzytelniania aplikacji lub w dowolnym momencie później możesz przechowywać token uwierzytelniania użytkownika w Block Store, aby móc go później odzyskać.
  2. Token będzie przechowywany lokalnie, a w miarę możliwości można utworzyć jego kopię zapasową w chmurze z pełnym szyfrowaniem.
  3. Dane są przenoszone, gdy użytkownik rozpoczyna proces przywracania na nowym urządzeniu.
  4. Jeśli użytkownik przywróci aplikację podczas procesu przywracania, może ona pobrać zapisany token z Block Store na nowym urządzeniu.

Zapisywanie tokena

Gdy użytkownik loguje się w Twojej aplikacji, możesz zapisać w aplikacji Block Store token uwierzytelniania wygenerowany dla tego użytkownika. Możesz przechowywać ten token z użyciem unikalnej wartości pary kluczy o maksymalnej wielkości 4 KB na wpis. Aby zapisać token, wywołaj setBytes() i setKey() w instancji StoreBytesData.Builder w celu zapisania danych logowania użytkownika na urządzeniu źródłowym. Po zapisaniu tokena w Block Store token jest szyfrowany i przechowywany lokalnie na urządzeniu.

Poniższy przykład pokazuje, jak zapisać token uwierzytelniania na urządzeniu lokalnym:

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

Użyj tokena domyślnego

Dane zapisywane przy użyciu StoreBytes bez klucza używają domyślnego klucza 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)
    }

Pobieram token

Później, gdy użytkownik przechodzi przez proces przywracania na nowym urządzeniu, Usługi Google Play najpierw zweryfikują go, a potem pobierają dane sklepu Block Store. Użytkownik zgodził się już na przywrócenie danych aplikacji w ramach procesu przywracania, więc nie jest wymagana dodatkowa zgoda użytkownika. Gdy użytkownik otworzy Twoją aplikację, możesz poprosić o token w Block Store, wywołując metodę retrieveBytes(). Pobrany token może być użyty, aby użytkownik był zalogowany na nowym urządzeniu.

Poniższy przykład pokazuje, jak pobrać wiele tokenów na podstawie konkretnych kluczy.

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

Pobieram wszystkie tokeny.

Poniżej znajdziesz przykład, jak pobrać wszystkie tokeny zapisane w 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)
  }

Poniżej znajdziesz przykład pobierania klucza domyślnego.

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)

Usuwanie tokenów

Usunięcie tokenów z BlockStore może być wymagane z tych powodów:

  • Użytkownik przechodzi przez proces wylogowania.
  • Token został unieważniony lub jest nieprawidłowy.

Podobnie jak w przypadku pobierania tokenów, możesz określić, które tokeny wymagają usunięcia, ustawiając tablicę kluczy wymagających usunięcia.

Poniżej pokazujemy, jak usuwać określone klucze.

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)

Usuń wszystkie tokeny

Przykład poniżej usuwa wszystkie tokeny zapisane obecnie w 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")
  }

Pełne szyfrowanie

Aby można było korzystać z pełnego szyfrowania, na urządzeniu musi być zainstalowany Android 9 lub nowszy, a użytkownik musi ustawić blokadę ekranu (kod PIN, wzór lub hasło). Aby sprawdzić, czy szyfrowanie będzie dostępne na urządzeniu, wywołaj tę stronę: isEndToEndEncryptionAvailable().

Poniższy przykład pokazuje, jak sprawdzić, czy szyfrowanie będzie dostępne podczas tworzenia kopii zapasowej w chmurze:

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

Włącz kopię zapasową w chmurze

Aby włączyć tworzenie kopii zapasowej w chmurze, dodaj do obiektu StoreBytesData metodę setShouldBackupToCloud(). Block Store będzie okresowo tworzyć kopię zapasową zapisanych bajtów w chmurze, jeśli zasada setShouldBackupToCloud() ma wartość Prawda.

Poniższy przykład pokazuje, jak włączyć tworzenie kopii zapasowej w chmurze tylko wtedy, gdy kopia zapasowa w chmurze jest w pełni szyfrowana:

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

Jak to sprawdzić

Aby przetestować procesy przywracania, podczas programowania użyj poniższych metod.

Odinstaluj i ponownie zainstaluj to samo urządzenie

Jeśli użytkownik włączy Usługi kopii zapasowej (możesz to sprawdzić w sekcji Ustawienia > Google > Kopia zapasowa), dane z blokad sklepu będą przechowywane przez całą aplikację odinstalowaną i ponowną.

Aby przeprowadzić test, wykonaj te czynności:

  1. Zintegruj interfejs BlockStore API z aplikacją testową.
  2. Użyj aplikacji testowej do wywołania interfejsu BlockStore API, aby przechowywać dane.
  3. Odinstaluj aplikację testową, a następnie ponownie zainstaluj ją na tym samym urządzeniu.
  4. Użyj aplikacji testowej do wywołania interfejsu BlockStore API, aby pobrać dane.
  5. Sprawdź, czy pobrane bajty są takie same jak te zapisane przed odinstalowaniem.

Między urządzeniami

W większości przypadków będzie to wymagać przywrócenia urządzenia docelowego do ustawień fabrycznych. Następnie możesz włączyć proces przywracania bezprzewodowego Androida lub przywracania kabla przez Google (w przypadku obsługiwanych urządzeń).

Przywracanie do Cloud

  1. Zintegruj interfejs Blockstore API z aplikacją testową. Aplikacja testowa musi zostać przesłana do Sklepu Play.
  2. Na urządzeniu źródłowym użyj aplikacji testowej, aby wywołać interfejs Blockstore API w celu przechowywania danych. Powinien on mieć wartość Prawda.
  3. W przypadku urządzeń w wersji O lub wyższej możesz ręcznie aktywować kopię zapasową w chmurze Block Store: otwórz Ustawienia > Google > Kopia zapasowa i kliknij przycisk „Utwórz kopię zapasową teraz”.
    1. Aby sprawdzić, czy kopia zapasowa Block Store została wykonana, możesz:
      1. Gdy kopia zapasowa zostanie utworzona, wyszukaj wiersze logu z tagiem „CloudSyncBpTkSvc”.
      2. Powinny być widoczne wiersze podobne do tego: „......, CloudSyncBpTkSvc: wynik synchronizacji: SUCCESS, ..., przesłany rozmiar: XXX bajtów ...”
    2. Po utworzeniu kopii zapasowej w chmurze Block Store następuje 5-minutowy okres oczekiwania. W ciągu tych 5 minut kliknięcie przycisku „Utwórz kopię zapasową teraz” nie uruchomi kolejnej kopii zapasowej w chmurze Block Store.
  4. Przywróć urządzenie docelowe do ustawień fabrycznych i wykonaj proces przywracania do chmury. Wybierz tę opcję, aby przywrócić aplikację testową podczas procesu przywracania. Więcej informacji o procesach przywracania do chmury znajdziesz w artykule Obsługiwane przepływy przywracania do chmury.
  5. Na urządzeniu docelowym użyj aplikacji testowej do wywołania interfejsu Blockstore API, aby pobrać dane.
  6. Sprawdź, czy pobrane bajty są takie same jak te zapisane na urządzeniu źródłowym.

Wymagania dotyczące urządzenia

Pełne szyfrowanie

  • Pełne szyfrowanie jest obsługiwane na urządzeniach z Androidem 9 (API 29) i nowszym.
  • Aby można było włączyć pełne szyfrowanie i prawidłowo szyfrować dane użytkownika, na urządzeniu musi być ustawiona blokada ekranu z kodem PIN, wzorem lub hasłem.

Proces przywracania danych z urządzenia

Aby przywrócić dane z urządzenia na urządzenie, musisz mieć urządzenie źródłowe i docelowe. Będą to 2 urządzenia przenoszące dane.

Aby można było tworzyć kopie zapasowe, urządzenia źródłowe muszą mieć zainstalowany Android 6 (API 23) lub nowszy.

Kieruj reklamy na urządzenia z Androidem 9 (API 29) lub nowszym, aby można było przywrócić dane.

Więcej informacji na temat procesu przywracania danych na urządzeniu znajdziesz tutaj.

Proces tworzenia i przywracania kopii zapasowej w chmurze

Tworzenie i przywracanie kopii zapasowych w chmurze będzie wymagać urządzenia źródłowego i docelowego.

Aby można było tworzyć kopie zapasowe, urządzenia źródłowe muszą mieć zainstalowany Android 6 (API 23) lub nowszy.

Urządzenia docelowe są obsługiwane w zależności od ich dostawców. Urządzenia Pixel mogą korzystać z tej funkcji Androida 9 (API 29), a wszystkie pozostałe muszą mieć zainstalowany Android 12 (API 31) lub nowszy.