Sklep blokowy

Wielu użytkowników w dalszym ciągu zarządza swoimi danymi logowania podczas konfigurowania nowego urządzenia z Androidem. Wykonywanie ręcznych czynności staje się trudne i często zmniejsza komfort korzystania z usługi. Block Store API, biblioteka oparta na Usługach Google Play, rozwiązuje ten problem, umożliwiając aplikacjom zapisywanie danych użytkownika bez złożoności i bez ryzyka związanego z zapisywaniem haseł.

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ększa to wygodę użytkowników, ponieważ nie musi widzieć ekranu logowania przy pierwszym uruchomieniu aplikacji na nowym urządzeniu.

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żytkowników i haseł.
• Wyeliminuj zakłócenia podczas procesu logowania.
• 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 sekcjach buildscript i allprojects w 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 Block pozwala deweloperom zapisywać i przywracać tablice 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. Te dane mogą być w pełni szyfrowane, a infrastruktura obsługująca Block Store działa w oparciu o infrastrukturę tworzenia i przywracania kopii zapasowych.

W tym przewodniku opisano przypadek użycia 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 po jej zakończeniu możesz zapisać token uwierzytelniania użytkownika w sklepie Block Store, aby móc go później pobrać.
2. Token będzie przechowywany lokalnie, a w miarę możliwości można też utworzyć jego kopię zapasową w chmurze z pełnym szyfrowaniem.
3. Dane są przenoszone, gdy użytkownik rozpocznie przywracanie na nowym urządzeniu.
4. Jeśli użytkownik przywróci Twoją aplikację podczas procesu przywracania, będzie ona mogła pobrać zapisany token z Block Store na nowym urządzeniu.

Zapisuję token

Gdy użytkownik zaloguje się w Twojej aplikacji, możesz zapisać token uwierzytelniania wygenerowany dla tego użytkownika w celu blokowania sklepu. Możesz przechowywać ten token przy użyciu 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 sklepie Block Store token jest szyfrowany i przechowywany lokalnie na urządzeniu.

Z przykładu poniżej dowiesz się, jak zapisać token uwierzytelniania na urządzeniu lokalnym:

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

Użyj tokena domyślnego

Dane zapisane z użyciem StoreBytes bez klucza używają domyślnego klucza 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)
    }

Pobieram token

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

Z przykładu poniżej dowiesz się, jak pobrać wiele tokenów na podstawie konkretnych kluczy.

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

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

Poniżej znajdziesz przykład, jak pobrać wszystkie tokeny zapisane w BlockStore.

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

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.

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)

Usuwanie tokenów

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

• Użytkownik wylogowuje się z konta.
• 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, które wymagają usunięcia.

Poniżej znajdziesz przykłady usuwania niektórych kluczy.

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)

Usuń wszystkie tokeny

Przykład poniżej usuwa wszystkie tokeny zapisane obecnie w 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()
client.deleteBytes(deleteAllRequest)
  .addOnSuccessListener { result: Boolean ->
    Log.d(TAG,
          "Any data found and deleted? $result")
  }

Pełne szyfrowanie

Aby korzystać z pełnego szyfrowania, na urządzeniu musi być zainstalowany Android 9 lub nowszy, a użytkownik musi mieć ustawioną blokadę ekranu (kod PIN, wzór lub hasło). Dostępność szyfrowania na urządzeniu możesz sprawdzić, wywołując metodę 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 metodę setShouldBackupToCloud() do obiektu StoreBytesData. Jeśli zasada setShouldBackupToCloud() ma wartość Prawda, Block Store okresowo tworzy kopię zapasową w chmurze zapisanych bajtów.

Z przykładu poniżej dowiesz się, 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 przeprowadzić test

Aby przetestować procesy przywracania, podczas programowania korzystaj z tych metod.

Odinstalowanie/ponowna instalacja na tym samym urządzeniu

Jeśli użytkownik włączy usługi kopii zapasowej (możesz to sprawdzić, klikając Ustawienia > Google > Kopia zapasowa), dane z aplikacji Block Store będą przechowywane podczas odinstalowania/ponownego zainstalowania aplikacji.

Aby przeprowadzić test, wykonaj te czynności:

1. Zintegruj interfejs BlockStore API z aplikacją testową.
2. Użyj aplikacji testowej, aby wywołać interfejs BlockStore API, aby zapisać dane.
3. Odinstaluj aplikację testową, a następnie zainstaluj ją ponownie 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.

Połączenia między urządzeniami

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

Przywracanie Cloud

1. Zintegruj Blockstore API z aplikacją testową. Aplikację testową należy przesłać 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ść true (prawda).
3. W przypadku urządzeń w wersji O i nowszych możesz ręcznie aktywować tworzenie kopii zapasowej 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 utworzona w chmurze:
      1. Gdy tworzenie kopii zapasowej zostanie ukończone, wyszukaj wiersze logu z tagiem „CloudSyncBpTkSvc”.
      2. Powinny pojawić się takie wiersze: „......, CloudSyncBpTkSvc: sync result: SUCCESS, ..., rozmiar przesłanego pliku: XXX bajtów ...”
   2. Po utworzeniu kopii zapasowej w chmurze Block Store rozpoczyna się 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óć ustawienia fabryczne na urządzeniu docelowym i wykonaj proces przywracania w chmurze. Wybierz, aby przywrócić aplikację testową podczas procesu przywracania. Więcej informacji o przepływach przywracania w chmurze znajdziesz w artykule Obsługiwane procesy przywracania do chmury.
5. Na urządzeniu docelowym użyj aplikacji testowej, aby wywołać interfejs Blockstore API w celu pobrania danych.
6. Sprawdź, czy pobrane bajty są takie same jak 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, urządzenie musi mieć ustawioną blokadę ekranu z kodem PIN, wzorem lub hasłem.

Proces przywracania urządzenia do urządzenia

Przywracanie danych z urządzenia na urządzenie wymaga użycia urządzenia źródłowego i docelowego. Będą to 2 urządzenia, które będą przesyłać dane.

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

Kierowanie na urządzenia z Androidem 9 (API 29) lub nowszym, które mają możliwość przywracania danych.

Więcej informacji na temat procesu przywracania urządzenia na urządzenie znajdziesz tutaj.

Proces tworzenia i przywracania kopii zapasowej w chmurze

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

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

Urządzenia docelowe są obsługiwane w zależności od dostawców. Urządzenia Pixel mogą korzystać z tej funkcji w Androidzie 9 (API 29) oraz na wszystkich pozostałych urządzeniach z Androidem 12 (API 31) lub nowszym.