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

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

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

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

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

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

शुरू करने से पहले, इन बातों का ध्यान रखें

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

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

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

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

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

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

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

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

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

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

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

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

जब कोई उपयोगकर्ता आपके ऐप्लिकेशन में साइन इन करता है, तब पुष्टि करने वाले उस टोकन को सेव किया जा सकता है जिसे आपने उस स्टोर के लिए जनरेट किया है. इस टोकन को कुंजी के जोड़े की एक खास वैल्यू का इस्तेमाल करके स्टोर किया जा सकता है. हर एंट्री में ज़्यादा से ज़्यादा 4 केबी की वैल्यू डाली जा सकती है. टोकन को सेव करने के लिए, setBytes() के इंस्टेंस पर 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 की स्थानीय निजी डेटा डायरेक्ट्री में सेव किया जाता है. कोई दूसरा ऐप्लिकेशन, डेटा फ़ाइल को सीधे तौर पर ऐक्सेस नहीं कर सकता. वे सिर्फ़ retrieveBytes() एपीआई की मदद से 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)
  }

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

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

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)

टोकन मिटाना

ब्लॉकस्टोर से टोकन मिटाने की ये वजहें हो सकती हैं:

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

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

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

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)

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

इस उदाहरण में, ब्लॉकस्टोर में सेव किए गए सभी टोकन मिटा दिए गए हैं:

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 एपीआई को अपने टेस्ट ऐप्लिकेशन में इंटिग्रेट करें.
अपना डेटा सेव करने के लिए, BlockStore API को शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
अपने टेस्ट ऐप्लिकेशन को अनइंस्टॉल करें. इसके बाद, उसे उसी डिवाइस पर फिर से इंस्टॉल करें.
अपना डेटा फिर से पाने के लिए, BlockStore API को शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
पुष्टि करें कि वापस लाए गए बाइट और अनइंस्टॉल करने से पहले सेव किए गए बाइट एक जैसे हैं.

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

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

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

Blockstore API को अपने टेस्ट ऐप्लिकेशन में इंटिग्रेट करें: टेस्ट ऐप्लिकेशन को Play Store पर सबमिट करें.
सोर्स डिवाइस पर अपने डेटा को स्टोर करने के लिए, BlockStore API को शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें. ऐसा तब होगा, जब backBackUpToCloud को 'सही है' पर सेट किया गया हो.
O और इसके बाद के वर्शन वाले डिवाइसों के लिए, मैन्युअल तौर पर 'ब्लॉक स्टोर' का क्लाउड बैकअप ट्रिगर किया जा सकता है: सेटिंग > Google > बैक अप पर जाकर, "अभी बैक अप लें" बटन पर क्लिक करें.
1. यह पुष्टि करने के लिए कि 'स्टोर को ब्लॉक करें' का क्लाउड बैक अप पूरा हो गया है, आप:
  1. बैक अप पूरा होने के बाद, "CloudSyncBpTkSvc" टैग वाली लॉग लाइन खोजें.
  2. आपको इस तरह की लाइनें दिख सकती हैं: “......, CloudSyncBpTkSvc: Sync result: SUCCESS, ..., uploaded color: XXX bytes ...”
2. 'ब्लॉक स्टोर' में क्लाउड बैक अप लेने के बाद, “कूल डाउन” करने का समय पांच मिनट होता है. पांच मिनट के अंदर, "अभी बैक अप लें" बटन पर क्लिक करके, अन्य ब्लॉक स्टोर क्लाउड बैक अप ट्रिगर नहीं होगा.
टारगेट डिवाइस को फ़ैक्ट्री रीसेट करें और क्लाउड रीस्टोर फ़्लो पूरा करें. डेटा वापस पाने की प्रक्रिया के दौरान, अपने टेस्ट ऐप्लिकेशन को पहले जैसा करने के लिए इसे चुनें. क्लाउड रीस्टोर फ़्लो के बारे में ज़्यादा जानकारी के लिए, साथ काम करने वाले क्लाउड रीस्टोर फ़्लो देखें.
टारगेट डिवाइस पर, डेटा वापस पाने के लिए Blockstore API को शुरू करने के लिए, टेस्ट ऐप्लिकेशन का इस्तेमाल करें.
पुष्टि करें कि दोबारा हासिल किए गए बाइट और सोर्स डिवाइस में सेव किए गए बाइट एक जैसे हैं.

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

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

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

एक डिवाइस से दूसरे डिवाइस पर पहुंचने का फ़्लो

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

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

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

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

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

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

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