इस पेज का अनुवाद Cloud Translation API से किया गया है.

स्टोर ब्लॉक करें

कई उपयोगकर्ता, नया Android डिवाइस सेट अप करते समय भी अपने क्रेडेंशियल मैनेज करते हैं डिवाइस. यह मैन्युअल प्रोसेस मुश्किल हो सकती है और अक्सर खराब होती है उपयोगकर्ता अनुभव. Block Store API, एक लाइब्रेरी है जो Google Play की मदद से काम करती है सेवाएं, इस समस्या को हल करने के लिए ऐप्लिकेशन को सेव करने का तरीका उपलब्ध कराती हैं उपयोगकर्ता के क्रेडेंशियल, जिनमें सेव करने से जुड़ी जटिलता या सुरक्षा का जोखिम नहीं है उपयोगकर्ता पासवर्ड.

Block Store API, आपके ऐप्लिकेशन को डेटा सेव करने की अनुमति देता है, ताकि वह बाद में ऐसा कर सके को फिर से ऐक्सेस करें. इसकी मदद से ज़्यादा जानकारी दी जा सकती है इस्तेमाल कर सकते हैं, क्योंकि उन्हें साइन-इन स्क्रीन देखने की ज़रूरत नहीं होती आपके ऐप्लिकेशन को नए डिवाइस पर पहली बार लॉन्च करते समय.

ब्लॉक स्टोर का इस्तेमाल करने के ये फ़ायदे हैं:

डेवलपर के लिए एन्क्रिप्ट (सुरक्षित) किए गए क्रेडेंशियल स्टोरेज की सुविधा. क्रेडेंशियल ये हैं जब मुमकिन हो, तब एंड-टू-एंड एन्क्रिप्टेड.
उपयोगकर्ता नाम और पासवर्ड के बजाय, टोकन सेव करें.
साइन-इन करने के फ़्लो में आने वाली परेशानी को दूर करें.
उपयोगकर्ताओं को जटिल पासवर्ड मैनेज करने के बोझ से बचाएं.
Google, उपयोगकर्ता की पहचान की पुष्टि करता है.

ध्यान दें: Block Store का इस्तेमाल करने से, उपयोगकर्ताओं को यह तय नहीं होता कि वे किस तरह के क्रेडेंशियल का इस्तेमाल कर सकते हैं इस्तेमाल नहीं किया जा सकता. उपयोगकर्ता अपने उपयोगकर्ता नाम और पासवर्ड, अपने Google खाते से साइन इन कर सकते हैं या किसी अन्य फ़ेडरेटेड आइडेंटिटी प्रोवाइडर से लिंक करने के लिए कहा जाता है. ब्लॉक स्टोर भी काम करता रहेगा.

शुरू करने से पहले

अपने ऐप्लिकेशन को तैयार करने के लिए, नीचे दिए गए सेक्शन में दिए गए चरणों को पूरा करें.

अपना ऐप्लिकेशन कॉन्फ़िगर करें

अपनी प्रोजेक्ट-लेवल build.gradle फ़ाइल में, Google की Maven शामिल करें डेटा स्टोर करने की जगह को, आपके buildscript, दोनों में और allprojects सेक्शन:

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

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

Google Play services को जोड़ें ब्लॉक स्टोर एपीआई की डिपेंडेंसी मॉड्यूल की Gradle बिल्ड फ़ाइल, जो आम तौर पर app/build.gradle होता है:

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

यह कैसे काम करता है

ब्लॉक स्टोर की मदद से डेवलपर, 16 बाइट वाले डेटा को सेव और वापस ला सकते हैं. इसकी मदद से, उपयोगकर्ता के मौजूदा सेशन से जुड़ी अहम जानकारी सेव की जा सकती है. साथ ही, इस जानकारी को अपने हिसाब से सेव किया जा सकता है. यह डेटा पूरी तरह सुरक्षित (E2EE) हो सकता है. साथ ही, Block Store के साथ काम करने वाला इंफ़्रास्ट्रक्चर, बैकअप और पहले जैसा करने की सुविधा वाले इन्फ़्रास्ट्रक्चर पर बनाया गया है.

इस गाइड में, उपयोगकर्ता के टोकन को ब्लॉक स्टोर में सेव करने के इस्तेमाल के उदाहरण के बारे में बताया गया है. नीचे दिए गए चरण इस बात की जानकारी देते हैं कि Block Store का इस्तेमाल करने वाला ऐप्लिकेशन कैसे काम करेगा:

अपने ऐप्लिकेशन की पुष्टि करने के दौरान या उसके बाद, किसी भी समय यह जानकारी सेव की जा सकती है उपयोगकर्ता के पुष्टि करने वाले टोकन को ब्लॉक करें, ताकि उसे बाद में वापस पाया जा सके.
टोकन को डिवाइस पर ही सेव किया जाएगा और इसका बैक अप क्लाउड पर भी लिया जा सकता है, जब मुमकिन हो, तब एंड-टू-एंड एन्क्रिप्टेड.
जब उपयोगकर्ता किसी नए डिवाइस पर डेटा वापस पाने की प्रोसेस शुरू करता है, तब डेटा को ट्रांसफ़र किया जाता है.
अगर उपयोगकर्ता डेटा को पहले जैसा करने की प्रोसेस के दौरान आपके ऐप्लिकेशन को पहले जैसा करता है, तो आपका ऐप्लिकेशन ये काम कर सकता है: नए डिवाइस पर Block Store से सेव किया गया टोकन वापस पाएं.

टोकन सेव करना

जब कोई उपयोगकर्ता आपके ऐप्लिकेशन में साइन इन करता है, तो आपके पास उस उपयोगकर्ता के लिए जनरेट किए गए पुष्टि करने वाले टोकन को स्टोर को ब्लॉक करने के लिए सेव करने का विकल्प होता है. की-पेयर की यूनीक वैल्यू का इस्तेमाल करके, इस टोकन को स्टोर किया जा सकता है. हर एंट्री के लिए, ज़्यादा से ज़्यादा 4 केबी का होना चाहिए. टोकन सेव करने के लिए, setBytes() को कॉल करें और setKey() के एक इंस्टेंस पर StoreBytesData.Builder का इस्तेमाल, उपयोगकर्ता के क्रेडेंशियल को सोर्स डिवाइस में सेव करने के लिए किया जाता है. टोकन सेव करने के बाद ब्लॉक स्टोर का इस्तेमाल करने पर, टोकन को एन्क्रिप्ट (सुरक्षित) करके डिवाइस पर सेव करके रखा जाता है.

नीचे दिया गया सैंपल, पुष्टि करने वाले टोकन को सेव करने का तरीका बताता है स्थानीय डिवाइस:

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

डिफ़ॉल्ट टोकन का इस्तेमाल करें

बिना किसी कुंजी के StoreBytes का इस्तेमाल करके सेव किया गया डेटा, डिफ़ॉल्ट कुंजी 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)
    }

डिवाइस पर डेटा कैसे सेव किया जाता है और डेटा को कौन ऐक्सेस कर सकता है?

डिवाइस पर, BlockStore का डेटा Google Play Services में सेव किया जाता है लोकल प्राइवेट डेटा डायरेक्ट्री में बदल जाएगा. कोई भी अन्य ऐप्लिकेशन डेटा फ़ाइल को सीधे ऐक्सेस नहीं कर सकता. वे ये काम कर सकते हैं BlockStore डेटा को सिर्फ़ retrieveBytes() एपीआई और ऐप्लिकेशन से ऐक्सेस करें अपने-आप सेव हुए डेटा को ही हासिल कर सकता है. Google Play services, इन दोनों की जांच करता है पैकेज का नाम और हस्ताक्षर.

टोकन फिर से हासिल किया जा रहा है

बाद में, जब उपयोगकर्ता किसी नए डिवाइस पर डेटा वापस पाने की प्रोसेस से गुज़रता है इस डिवाइस पर, Google Play services पहले उपयोगकर्ता की पुष्टि करती है और फिर आपके ब्लॉक को वापस लेती है डेटा सेव करें. उपयोगकर्ता ने पहले ही इस बात की सहमति दे दी है कि वह आपके ऐप्लिकेशन का डेटा वापस ला देगा की प्रक्रिया पूरी करनी होगी. इसलिए, किसी और सहमति की ज़रूरत नहीं है. जब उपयोगकर्ता खुलता है तो आप इस नंबर पर कॉल करके Block Store से अपने टोकन का अनुरोध कर सकते हैं retrieveBytes(). इसके बाद, हासिल किए गए टोकन का इस्तेमाल उपयोगकर्ता को नई सदस्यता में साइन इन रखने के लिए किया जा सकता है डिवाइस.

नीचे दिया गया नमूना खास कुंजियों के आधार पर एक से ज़्यादा टोकन पाने का तरीका बताता है.

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

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

सभी टोकन वापस लाए जा रहे हैं.

ब्लॉकस्टोर में सेव किए गए सभी टोकन को वापस पाने का तरीका नीचे बताया गया है.

Java

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

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

नीचे डिफ़ॉल्ट कुंजी को फिर से पाने का तरीका बताया गया है.

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)

टोकन मिटाए जा रहे हैं

BlockStore से टोकन मिटाने की ज़रूरत इन वजहों से हो सकती है:

उपयोगकर्ता, साइन आउट करने के यूज़र फ़्लो को पार कर जाता है.
टोकन रद्द कर दिया गया है या अमान्य है.

टोकन पाने की तरह ही, आपके पास यह बताने का विकल्प है कि कौनसे टोकन मिटाने हैं. इसके लिए, आपको कुंजियों का कलेक्शन सेट करके ऐसा करना होगा.

नीचे कुछ कुंजियों को मिटाने का उदाहरण दिया गया है.

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)

सभी टोकन मिटाएं

नीचे दिया गया उदाहरण, फ़िलहाल 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")
  }

पूरी तरह सुरक्षित (E2EE)

डिवाइस को पूरी तरह सुरक्षित (E2EE) करने के लिए, यह ज़रूरी है कि डिवाइस डिवाइस, Android 9 या इसके बाद के वर्शन पर चल रहा हो और उपयोगकर्ता ने स्क्रीन लॉक सेट किया हो उनके डिवाइस के लिए (पिन, पैटर्न या पासवर्ड). यह पुष्टि की जा सकती है कि एन्क्रिप्ट (सुरक्षित) करने की सुविधा isEndToEndEncryptionAvailable() पर कॉल करके डिवाइस में उपलब्ध कराया जा सकता है.

नीचे दिए गए उदाहरण में, यह पुष्टि करने का तरीका बताया गया है कि इस दौरान एन्क्रिप्ट (सुरक्षित) करने की सुविधा उपलब्ध होगी या नहीं क्लाउड बैकअप:

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

क्लाउड बैकअप चालू करें

क्लाउड बैकअप सक्षम करने के लिए, setShouldBackupToCloud() आपके StoreBytesData ऑब्जेक्ट है. ब्लॉक स्टोर समय-समय पर, क्लाउड पर सेव की गई बाइट का बैकअप तब लेता है, जब setShouldBackupToCloud() को 'सही' के तौर पर सेट किया गया है.

नीचे दिया गया सैंपल, सिर्फ़ क्लाउड बैकअप के दौरान क्लाउड बैकअप को चालू करने का तरीका बताता है पूरी तरह सुरक्षित (E2EE) होता है:

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

टेस्ट करने का तरीका

डेटा वापस लाने की प्रोसेस की जांच करने के लिए, डेवलपमेंट के दौरान नीचे दिए गए तरीकों का इस्तेमाल करें फ़्लो.

उसी डिवाइस पर अनइंस्टॉल किया गया/फिर से इंस्टॉल किया गया

अगर उपयोगकर्ता बैकअप सेवाओं को चालू करता है (इसे सेटिंग > Google > बैकअप पर देखा जा सकता है), स्टोर डेटा को ब्लॉक करें ऐप्लिकेशन अनइंस्टॉल/फिर से इंस्टॉल करने के दौरान भी बनी रहती है.

जांच करने के लिए, यहां दिया गया तरीका अपनाएं:

BlockStore API को अपने टेस्ट ऐप्लिकेशन के साथ इंटिग्रेट करें.
अपना डेटा सेव करने के लिए, BlockStore API शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
टेस्ट ऐप्लिकेशन को अनइंस्टॉल करें. इसके बाद, उसी डिवाइस पर ऐप्लिकेशन को फिर से इंस्टॉल करें.
अपना डेटा वापस पाने के लिए, BlockStore API को शुरू करने के लिए टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
पुष्टि करें कि वापस हासिल की गई बाइट वही हैं जो पहले स्टोर की गई थीं अनइंस्टॉल किया जा सकता है.

डिवाइस-से-डिवाइस

ज़्यादातर मामलों में, टारगेट किए गए डिवाइस को फ़ैक्ट्री रीसेट करना पड़ता है. आप फिर Android वायरलेस रिस्टोर फ़्लो डालें या Google केबल रीस्टोर (उन डिवाइसों के लिए जिन पर यह सुविधा काम करती है).

क्लाउड पर डेटा वापस लाना

Blockstore API को अपने टेस्ट ऐप्लिकेशन के साथ इंटिग्रेट करें. परीक्षण ऐप्लिकेशन को यह होना चाहिए Play Store पर सबमिट किया जाता है.
सोर्स डिवाइस पर, स्टोर करने के लिए Blockstore API को शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें आपका डेटा सही पर सेट होना चाहिए.
O और उसके बाद के वर्शन वाले डिवाइसों के लिए, Block Store क्लाउड बैकअप को मैन्युअल तरीके से ट्रिगर किया जा सकता है: Settings > पर जाएं Google > बैकअप लें, “अभी बैकअप लें” बटन पर क्लिक करें.
1. ब्लॉक स्टोर क्लाउड बैकअप की प्रोसेस पूरी हो गई है, इसकी पुष्टि करने के लिए:
  1. बैकअप पूरा होने के बाद, टैग वाली लॉग पंक्तियां खोजें “CloudSyncBpTkSvc”.
  2. आपको इस तरह की लाइनें दिखेंगी: “......, CloudSyncBpTkSvc: सिंक नतीजा: हो गया, ..., अपलोड किया गया साइज़: XXX बाइट ...”
2. ब्लॉक स्टोर क्लाउड बैकअप के बाद, पांच मिनट का “कूल डाउन” पीरियड होता है. उस पांच मिनट के अंदर, “अभी बैकअप लें” बटन पर क्लिक करने से, एक और Block Store क्लाउड बैकअप.
टारगेट डिवाइस को फ़ैक्ट्री रीसेट करें और क्लाउड पर डेटा वापस पाने की प्रोसेस पूरी करें. चुनें का इस्तेमाल करें. इसके बारे में ज़्यादा जानकारी पाने के लिए, क्लाउड रीस्टोर फ़्लो, काम करने वाले क्लाउड रीस्टोर फ़्लो देखें.
टारगेट किए गए डिवाइस पर, जांच के लिए बनाए गए ऐप्लिकेशन का इस्तेमाल करके Blockstore API को शुरू करें आपका डेटा वापस आ सकता है.
पुष्टि करें कि हासिल की गई बाइट वही हैं जो सोर्स डिवाइस.

डिवाइस से जुड़ी ज़रूरी शर्तें

एंड-टू-एंड एन्क्रिप्शन (E2EE)

एंड-टू-एंड एन्क्रिप्शन (E2EE) की सुविधा, Android 9 (एपीआई 29) और उसके बाद के वर्शन वाले डिवाइसों पर काम करती है.
डिवाइस में पिन, पैटर्न या पासवर्ड के साथ स्क्रीन लॉक सेट होना चाहिए, ताकि उपयोगकर्ता के डेटा को सही तरीके से एन्क्रिप्ट (सुरक्षित) किया जा सके और एंड-टू-एंड एन्क्रिप्शन (E2EE) की सुविधा चालू की जा सके.

डिवाइस से डिवाइस पर डेटा वापस लाने की प्रोसेस

डिवाइस टू डिवाइस रिस्टोर के लिए आपके पास एक सोर्स डिवाइस और टारगेट किया गया डिवाइस होना चाहिए. ये दोनों डिवाइस, डेटा ट्रांसफ़र कर रहे हैं.

बैक अप लेने के लिए, सोर्स डिवाइसों में Android 6 (एपीआई 23) और उसके बाद का वर्शन होना चाहिए.

Android 9 (एपीआई 29) और उसके बाद के वर्शन वाले डिवाइसों को टारगेट करें, ताकि उन्हें पहले जैसा किया जा सके.

डिवाइस से डिवाइस पर डेटा वापस लाने की प्रोसेस के बारे में ज़्यादा जानकारी यहां मिल सकती है.

क्लाउड बैकअप और डेटा वापस पाने की प्रोसेस

क्लाउड पर बैकअप लेने और डेटा वापस पाने के लिए, आपके पास सोर्स डिवाइस और टारगेट किया गया डिवाइस होना चाहिए.

टारगेट डिवाइस उनके वेंडर के आधार पर काम करते हैं. Pixel डिवाइस, Android 9 (एपीआई 29) पर इस सुविधा का इस्तेमाल कर सकते हैं. साथ ही, अन्य सभी डिवाइसों में Android 12 (एपीआई 31) या उसके बाद का वर्शन होना चाहिए.