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

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

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

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

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

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

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

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

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

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

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

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

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

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

यह सुविधा कैसे काम करती है

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

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

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

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

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

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

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_ बराबर_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 की लोकल निजी डेटा डायरेक्ट्री में सेव होता है. कोई भी दूसरा ऐप्लिकेशन इस डेटा फ़ाइल को सीधे ऐक्सेस नहीं कर सकता. वे सिर्फ़ retrieveBytes() API की मदद से, BlockStore डेटा को ऐक्सेस कर सकते हैं. कोई ऐप्लिकेशन, सिर्फ़ उस डेटा को ऐक्सेस कर सकता है जिसे ब्लॉक किया गया हो. Google Play services, पैकेज के नाम और हस्ताक्षर, दोनों की जांच करती है.

टोकन वापस पाना

बाद में, जब कोई उपयोगकर्ता किसी नए डिवाइस पर डेटा वापस पाने की प्रोसेस से गुज़रता है, तो Google Play services सबसे पहले उस उपयोगकर्ता की पुष्टि करती है. इसके बाद, वह आपके 'ब्लॉक करें' स्टोर के डेटा को वापस लाती है. उपयोगकर्ता ने आपके ऐप्लिकेशन का डेटा वापस लाने की प्रक्रिया के तहत उसे पहले जैसा करने के लिए पहले ही सहमति दे दी है. इसलिए, किसी अन्य सहमति की ज़रूरत नहीं है. जब उपयोगकर्ता आपका ऐप्लिकेशन खोलता है, तब आपके पास ब्लॉक स्टोर से 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 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)
  }

सभी टोकन फ़ेच किए जा रहे हैं.

यहां 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)
  }

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

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

क्लाउड बैकअप की सुविधा चालू करें

क्लाउड बैकअप चालू करने के लिए, अपने StoreBytesData ऑब्जेक्ट में setShouldBackupToCloud() तरीका जोड़ें. जब 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 पर सबमिट करना ज़रूरी है.
सोर्स डिवाइस पर, अगर BackUpToCloud को 'सही' पर सेट किया जाता है, तो अपने डेटा को स्टोर करने के लिए ब्लॉकस्टोर एपीआई शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
O और उसके बाद के वर्शन वाले डिवाइसों के लिए, आप ब्लॉक स्टोर क्लाउड बैकअप को मैन्युअल तरीके से ट्रिगर कर सकते हैं: सेटिंग > Google > बैकअप पर जाएं. इसके बाद, “अभी बैकअप लें” बटन पर क्लिक करें.
1. ब्लॉक स्टोर क्लाउड बैकअप हो गया है या नहीं, इसकी पुष्टि करने के लिए:
  1. बैकअप पूरा हो जाने के बाद, “CloudSyncBpTkSvc” टैग वाली लॉग लाइनें खोजें.
  2. आपको इस तरह की लाइनें दिखनी चाहिए: “......, CloudSyncBpTkSvc: Sync result: बेहतरीन, ..., अपलोड किया गया साइज़: XXX बाइट ...”
2. ब्लॉक स्टोर के क्लाउड बैकअप के बाद, पांच मिनट का "कूल डाउन" पीरियड शुरू होता है. बस पांच मिनट के अंदर, “अभी बैकअप लें” बटन पर क्लिक करने से, कोई नया ब्लॉक स्टोर क्लाउड बैकअप ट्रिगर नहीं होगा.
टारगेट डिवाइस को फ़ैक्ट्री रीसेट करें और क्लाउड वापस पाने की प्रक्रिया शुरू करें. पहले जैसा करने के दौरान अपने टेस्ट ऐप्लिकेशन को वापस लाने के लिए यह विकल्प चुनें. क्लाउड डेटा को पहले जैसा करने के फ़्लो के बारे में ज़्यादा जानने के लिए, इस्तेमाल किए जा सकने वाले क्लाउड वापस लाने के फ़्लो देखें.
टारगेट डिवाइस पर, अपना डेटा पाने के लिए ब्लॉकस्टोर एपीआई शुरू करने के लिए टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
पुष्टि करें कि वापस लाई गई बाइट और सोर्स डिवाइस में सेव किए गए बाइट एक ही हैं.

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

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

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

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

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

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

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

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

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

क्लाउड बैकअप और डेटा वापस पाने की सुविधा के लिए, सोर्स डिवाइस और टारगेट डिवाइस की ज़रूरत होगी.

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