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

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

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

Block Store का इस्तेमाल करने के ये फ़ायदे हैं:

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

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

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

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

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

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

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

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

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

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

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

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

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

टोकन सेव करना

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

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

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

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

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

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

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

यहां दिए गए सैंपल में, खास कुंजियों के आधार पर कई टोकन वापस पाने का तरीका बताया गया है.

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

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 में सेव किए गए सभी टोकन वापस पाने का तरीका बताया गया है.

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

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

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

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)

टोकन मिटाना

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

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

टोकन वापस पाने की तरह ही, यह भी तय किया जा सकता है कि किन टोकन को मिटाना है. इसके लिए, उन कुंजियों का कलेक्शन सेट करें जिन्हें मिटाना है.

यहां दिए गए उदाहरण में, कुछ कुंजियों को मिटाने का तरीका बताया गया है:

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

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

यहां दिए गए उदाहरण में, Block Store में सेव किए गए सभी टोकन मिटाने का तरीका बताया गया है:

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

// Delete all data.
val deleteAllRequest = DeleteBytesRequest.Builder()
        .setDeleteAll(true)
        .build()
client.deleteBytes(deleteAllRequest)
  .addOnSuccessListener { result -> 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() को 'सही है' पर सेट करने पर, Block Store समय-समय पर क्लाउड में सेव किए गए बाइट का बैकअप लेगा.

यहां दिए गए सैंपल में, क्लाउड बैकअप की सुविधा चालू करने का तरीका बताया गया है. यह सुविधा सिर्फ़ तब चालू की जा सकती है, जब क्लाउड बैकअप पूरी तरह सुरक्षित हो:

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

जांच करने का तरीका

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

एक ही डिवाइस पर अनइंस्टॉल और फिर से इंस्टॉल करना

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

टेस्ट करने के लिए, यह तरीका अपनाएं:

1. अपने टेस्ट ऐप्लिकेशन में Block Store API को इंटिग्रेट करें.
2. अपने डेटा को सेव करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करके Block Store API को कॉल करें.
3. अपने टेस्ट ऐप्लिकेशन को अनइंस्टॉल करें. इसके बाद, उसी डिवाइस पर अपने ऐप्लिकेशन को फिर से इंस्टॉल करें.
4. अपना डेटा वापस पाने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करके Block Store API को कॉल करें.
5. पुष्टि करें कि वापस लाए गए बाइट, अनइंस्टॉल करने से पहले सेव किए गए बाइट के बराबर हों.

एक डिवाइस से दूसरे डिवाइस पर

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

क्लाउड रीस्टोर

1. Block Store API को अपने टेस्ट ऐप्लिकेशन के साथ इंटिग्रेट करें. टेस्ट ऐप्लिकेशन को Play Store पर सबमिट करना ज़रूरी है.
2. सोर्स डिवाइस पर, टेस्ट ऐप्लिकेशन का इस्तेमाल करके Block Store API को चालू करें, ताकि आपका डेटा सेव किया जा सके. इसके लिए, shouldBackUpToCloud को true पर सेट करें.
3. Android 8.0 (एपीआई लेवल 26) या इसके बाद के वर्शन वाले डिवाइसों पर, Block Store क्लाउड बैकअप को मैन्युअल तरीके से ट्रिगर किया जा सकता है: सेटिंग > Google > बैकअप पर जाएं और "अभी बैकअप लें" बटन पर क्लिक करें.
   1. Block Store क्लाउड बैकअप की सुविधा चालू है या नहीं, इसकी पुष्टि करने के लिए:
      1. बैकअप पूरा होने के बाद, [CloudSyncBackupTaskService] टैग वाली लॉग लाइनें खोजें.
      2. आपको इस तरह की लाइनें दिखेंगी: ..., [CloudSyncBackupTaskService] sync result: SUCCESS, ..., uploaded size: [size] bytes ...
   2. Block Store क्लाउड बैकअप के बाद, पांच मिनट का "कूलडाउन" पीरियड होता है. इन पांच मिनट के दौरान, "अभी बैकअप लें" बटन पर क्लिक करने से, Block Store का दूसरा क्लाउड बैकअप ट्रिगर नहीं होगा.
4. टारगेट डिवाइस को फ़ैक्ट्री रीसेट करें और क्लाउड से डेटा वापस पाने की प्रोसेस पूरी करें. रीस्टोर करने की प्रोसेस के दौरान, टेस्ट ऐप्लिकेशन को रीस्टोर करने के लिए, चुनें. क्लाउड से डेटा वापस पाने के फ़्लो के बारे में ज़्यादा जानने के लिए, क्लाउड से डेटा वापस पाने के लिए इस्तेमाल किए जा सकने वाले फ़्लो लेख पढ़ें.
5. टारगेट डिवाइस पर, टेस्ट ऐप्लिकेशन का इस्तेमाल करके Block Store API को कॉल करें, ताकि आपका डेटा वापस लाया जा सके.
6. पुष्टि करें कि वापस पाए गए बाइट, सोर्स डिवाइस में सेव किए गए बाइट के बराबर हों.

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

Block Store की कार्रवाइयों में हिस्सा लेने वाले डिवाइसों के लिए, यहां दी गई ज़रूरी शर्तें देखें.

पूरी तरह सुरक्षित (E2EE) करने की सुविधा

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

एक डिवाइस से दूसरे डिवाइस में डेटा ट्रांसफ़र करने का फ़्लो

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

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

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

एक डिवाइस से दूसरे डिवाइस पर डेटा ट्रांसफ़र करने के बारे में ज़्यादा जानने के लिए, एक डिवाइस से दूसरे डिवाइस पर डेटा ट्रांसफ़र करने के लिए, इस्तेमाल किए जा सकने वाले तरीके देखें.

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

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

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

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