Android गेम के लिए सेव किए गए गेम

इस गाइड में बताया गया है कि Google Play की गेम सेवाओं से मिला स्नैपशॉट एपीआई. ये एपीआई यहां com.google.android.gms.games.snapshot और com.google.android.gms.games पैकेज.

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

इस सुविधा के बारे में जानकारी के लिए, यहां जाएं: सेव किए गए गेम की खास जानकारी.

• गेम सेव करने की सुविधा चालू करें Play Console में आपके गेम के लिए उपलब्ध होते हैं.
• सेव किया गया गेम कोड सैंपल डाउनलोड करें और यहां देखें: Android सैंपल पेज.
• यहां दिए गए सुझावों के बारे में जानें क्वालिटी चेकलिस्ट.

स्नैपशॉट क्लाइंट पाएं

स्नैपशॉट एपीआई का इस्तेमाल शुरू करने के लिए, आपके गेम को पहले SnapshotsClient ऑब्जेक्ट. ऐसा करने के लिए, Games.getSnapshotsClient() तरीका इस्तेमाल किया और इस प्रक्रिया में पास किया जा रहा है: गतिविधि.

ध्यान दें: SnapshotsClient क्लास, Google Play services का इस्तेमाल करती है Task क्लास का इस्तेमाल करें. इस बारे में ज़्यादा जानने के लिए थ्रेड वाले काम को मैनेज करने के लिए टास्क का इस्तेमाल किया जा सकता है. इसके लिए, Tasks API की डेवलपर गाइड.

ड्राइव के स्कोप के बारे में बताएं

स्नैपशॉट एपीआई, Google Drive API का इस्तेमाल करता है सेव किए गए गेम स्टोरेज के लिए. Drive API ऐक्सेस करने के लिए, आपके ऐप्लिकेशन को Drive.SCOPE_APPFOLDER स्कोप का इस्तेमाल करें.

यहां दिए गए उदाहरण के हिसाब से, onResume() साइन-इन गतिविधि के लिए दूसरा तरीका चुनें:

@Override
protected void onResume() {
  super.onResume();
  signInSilently();
}

private void signInSilently() {
  GoogleSignInOptions signInOption =
      new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
          // Add the APPFOLDER scope for Snapshot support.
          .requestScopes(Drive.SCOPE_APPFOLDER)
          .build();

  GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOption);
  signInClient.silentSignIn().addOnCompleteListener(this,
      new OnCompleteListenerG<oogleSignInAccount(>) {
        @Override
        public void onComplete(@NonNull TaskG<oogleSignInAccount >task) {
          if (task.isSuccessful()) {
            onConnected(task.getResult());
          } else {
            // Player will need to sign-in explicitly using via UI
          }
        }
      });
}

सेव किए गए गेम दिखाएं

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

जब खिलाड़ी आपके गेम में सेव/वापस लाने का विकल्प चुन लेते हैं, तो आपका गेम ये काम कर सकता है: इसके अलावा, एक स्क्रीन भी दिखेगी. इस स्क्रीन पर खिलाड़ियों को, सेव किए गए नए कॉन्टेंट की जानकारी डालने के लिए कहा जाएगा या सेव किए गए मौजूदा गेम को चुनें.

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

सेव किए गए गेम का डिफ़ॉल्ट यूज़र इंटरफ़ेस (यूआई) लॉन्च करने के लिए:

1. इनाम पाने के लिए SnapshotsClient.getSelectSnapshotIntent() पर कॉल करें Intent सेव किए गए डिफ़ॉल्ट गेम चुनने का यूज़र इंटरफ़ेस (यूआई) लॉन्च करने के लिए.
2. कॉल करें startActivityForResult() और उसे Intent. कॉल पूरा होने पर, गेम, सेव किए गए गेम को चुनने के लिए यूज़र इंटरफ़ेस (यूआई) दिखाता है. आपके चुने गए विकल्पों के साथ.

यहां दिए गए उदाहरण में, सेव किए गए डिफ़ॉल्ट गेम चुनने के यूज़र इंटरफ़ेस (यूआई) को लॉन्च करने का तरीका बताया गया है:

private static final int RC_SAVED_GAMES = 9009;

private void showSavedGamesUI() {
  SnapshotsClient snapshotsClient =
      PlayGames.getSnapshotsClient(this);
  int maxNumberOfSavedGamesToShow = 5;

  Task<Intent> intentTask = snapshotsClient.getSelectSnapshotIntent(
      "See My Saves", true, true, maxNumberOfSavedGamesToShow);

  intentTask.addOnSuccessListener(new OnSuccessListener<Intent>() {
    @Override
    public void onSuccess(Intent intent) {
      startActivityForResult(intent, RC_SAVED_GAMES);
    }
  });
}

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

नीचे दिया गया कोड स्निपेट onActivityResult():

private String mCurrentSaveName = "snapshotTemp";

/**
 * This callback will be triggered after you call startActivityForResult from the
 * showSavedGamesUI method.
 */
@Override
protected void onActivityResult(int requestCode, int resultCode,
                                Intent intent) {
  if (intent != null) {
    if (intent.hasExtra(SnapshotsClient.EXTRA_SNAPSHOT_METADATA)) {
      // Load a snapshot.
      SnapshotMetadata snapshotMetadata =
          intent.getParcelableExtra(SnapshotsClient.EXTRA_SNAPSHOT_METADATA);
      mCurrentSaveName = snapshotMetadata.getUniqueName();

      // Load the game data from the Snapshot
      // ...
    } else if (intent.hasExtra(SnapshotsClient.EXTRA_SNAPSHOT_NEW)) {
      // Create a new snapshot named with a unique string
      String unique = new BigInteger(281, new Random()).toString(13);
      mCurrentSaveName = "snapshotTemp-" + unique;

      // Create the new snapshot
      // ...
    }
  }
}

सेव किए गए गेम में बदलाव करने की अनुमति दें

सेव किए गए गेम में कॉन्टेंट सेव करने के लिए:

1. एसिंक्रोनस रूप से के माध्यम से एक स्नैपशॉट खोलें SnapshotsClient.open().

2. वापस पाएं कॉल करके टास्क के नतीजे से Snapshot ऑब्जेक्ट जुड़ा है SnapshotsClient.DataOrConflict.getData().

3. वापस पाएं SnapshotContents के साथ इंस्टेंस SnapshotsClient.SnapshotConflict.

4. कॉल करें SnapshotContents.writeBytes() प्लेयर के डेटा को बाइट फ़ॉर्मैट में स्टोर करने के लिए.

5. अपने सभी बदलाव लिख लेने के बाद, SnapshotsClient.commitAndClose() आपके बदलावों को Google के सर्वर पर भेजने के लिए. मेथड कॉल में, आपका गेम ये काम कर सकता है: इसके अलावा, अतिरिक्त जानकारी देकर Play की गेम सेवाओं को बताया जा सकता है कि सेव किया गया यह गेम खिलाड़ियों को दिखाना है. इस जानकारी को SnapshotMetaDataChange ऑब्जेक्ट है, जिसका इस्तेमाल करके आपका गेम बनाता है SnapshotMetadataChange.Builder.

नीचे दिया गया स्निपेट दिखाता है कि आपका गेम, सेव किए गए गेम में किस तरह बदलाव कर सकता है:

private Task<SnapshotMetadata> writeSnapshot(Snapshot snapshot,
                                             byte[] data, Bitmap coverImage, String desc) {

  // Set the data payload for the snapshot
  snapshot.getSnapshotContents().writeBytes(data);

  // Create the change operation
  SnapshotMetadataChange metadataChange = new SnapshotMetadataChange.Builder()
      .setCoverImage(coverImage)
      .setDescription(desc)
      .build();

  SnapshotsClient snapshotsClient =
      PlayGames.getSnapshotsClient(this);

  // Commit the operation
  return snapshotsClient.commitAndClose(snapshot, metadataChange);
}

आपके ऐप्लिकेशन के कॉल करते समय, अगर प्लेयर का डिवाइस किसी नेटवर्क से कनेक्ट नहीं है SnapshotsClient.commitAndClose() Play की गेम सेवाएं, सेव किए गए गेम के डेटा को डिवाइस पर सेव करती हैं. डिवाइस पर री-कनेक्शन, Play की गेम सेवाएं, लोकल कैश मेमोरी में सेव किए गए, गेम में किए गए बदलावों को इस तरह सिंक करती हैं: Google के सर्वर पर.

सेव किए गए गेम लोड करें

जिस खिलाड़ी ने फ़िलहाल साइन इन किया हुआ है उसके सेव किए गए गेम वापस पाने के लिए:

1. एसिंक्रोनस रूप से इसके साथ एक स्नैपशॉट खोलें SnapshotsClient.open().

2. ईतरीव द Snapshot कॉल करके टास्क के नतीजे से ऑब्जेक्ट शेयर करें SnapshotsClient.DataOrConflict.getData(). वैकल्पिक रूप से, आपका गेम किसी खास यूआरएल को सेव किए गए गेम चुनने के यूज़र इंटरफ़ेस (यूआई) के ज़रिए स्नैपशॉट लें. ऐसा करने का तरीका यहां बताया गया है सेव किए गए गेम दिखाना.

3. वापस पाएं SnapshotContents के साथ इंस्टेंस SnapshotsClient.SnapshotConflict.

4. कॉल करें SnapshotContents.readFully() स्नैपशॉट का कॉन्टेंट पढ़ने के लिए.

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

Task<byte[]> loadSnapshot() {
  // Display a progress dialog
  // ...

  // Get the SnapshotsClient from the signed in account.
  SnapshotsClient snapshotsClient =
      PlayGames.getSnapshotsClient(this);

  // In the case of a conflict, the most recently modified version of this snapshot will be used.
  int conflictResolutionPolicy = SnapshotsClient.RESOLUTION_POLICY_MOST_RECENTLY_MODIFIED;

  // Open the saved game using its name.
  return snapshotsClient.open(mCurrentSaveName, true, conflictResolutionPolicy)
      .addOnFailureListener(new OnFailureListener() {
        @Override
        public void onFailure(@NonNull Exception e) {
          Log.e(TAG, "Error while opening Snapshot.", e);
        }
      }).continueWith(new Continuation<SnapshotsClient.DataOrConflict<Snapshot>, byte[]>() {
        @Override
        public byte[] then(@NonNull Task<SnapshotsClient.DataOrConflict<Snapshot>> task) throws Exception {
          Snapshot snapshot = task.getResult().getData();

          // Opening the snapshot was a success and any conflicts have been resolved.
          try {
            // Extract the raw data from the snapshot.
            return snapshot.getSnapshotContents().readFully();
          } catch (IOException e) {
            Log.e(TAG, "Error while reading Snapshot.", e);
          }

          return null;
        }
      }).addOnCompleteListener(new OnCompleteListener<byte[]>() {
        @Override
        public void onComplete(@NonNull Task<byte[]> task) {
          // Dismiss progress dialog and reflect the changes in the UI when complete.
          // ...
        }
      });
}

गेम से जुड़े, सेव किए गए विवादों को मैनेज करना

अपने गेम में स्नैपशॉट एपीआई का इस्तेमाल करते समय, कई सेव किए गए एक ही गेम पर पढ़ने और लिखने के लिए डिवाइस. ऐसी स्थिति में जब डिवाइस कुछ समय के लिए इंटरनेट से डिसकनेक्ट हो जाता है और बाद में फिर से कनेक्ट हो जाता है. ऐसा होने पर डेटा से जुड़ी समस्याएं पैदा करता है जिससे खिलाड़ी के डिवाइस पर सेव किए गए गेम को सेव किया जाता है वह Google के सर्वर में संग्रहित रिमोट वर्शन के साथ सिंक से बाहर है.

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

जब Play की गेम सेवाओं को किसी डेटा में समस्या का पता चलता है, SnapshotsClient.DataOrConflict.isConflict() तरीका true का मान लौटाता है इस इवेंट में, SnapshotsClient.SnapshotConflict क्लास में सेव किए गए गेम के दो वर्शन होते हैं:

• सर्वर का वर्शन: यह Play की गेम सेवाओं के सबसे अप-टू-डेट वर्शन के बारे में जानकारी देता है प्लेयर के डिवाइस के लिए सही हो.

• लोकल वर्शन: प्लेयर के किसी डिवाइस पर, बदला गया वर्शन पाया गया जिसमें विरोधी कॉन्टेंट या मेटाडेटा शामिल हो. यह जानकारी अलग हो सकती है जिसे आपने सेव करने की कोशिश की थी.

आपके गेम को उपलब्ध कराए गए वर्शन या सेव किए गए गेम के दो वर्शन के डेटा को मर्ज कर रहे हों.

सेव किए गए गेम से जुड़े विवादों का पता लगाने और उन्हें हल करने के लिए:

1. कॉल करें SnapshotsClient.open(). टास्क के नतीजे में एक SnapshotsClient.DataOrConflict क्लास शामिल है.

2. कॉल करें SnapshotsClient.DataOrConflict.isConflict() तरीका. अगर परिणाम सही है, तो आपके पास समाधान करने का विवाद है.

3. कॉल करें SnapshotsClient.DataOrConflict.getConflict() को वापस पाने के लिए SnaphotsClient.snapshotConflict इंस्टेंस.

4. कॉल करें SnapshotsClient.SnapshotConflict.getConflictId() का इस्तेमाल करें. आपका गेम को इस वैल्यू की ज़रूरत है, ताकि बाद में समस्या हल करने का अनुरोध भेजा जा सके.

5. कॉल करें SnapshotsClient.SnapshotConflict.getConflictingSnapshot() स्थानीय वर्शन पाने के लिए.

6. कॉल करें SnapshotsClient.SnapshotConflict.getSnapshot() सर्वर वर्शन पाने के लिए.

7. गेम से जुड़ी समस्या हल करने के लिए, वह वर्शन चुनें जिसमें आपको गेम सेव करना है सर्वर को अंतिम वर्शन के रूप में रखता है और उसे SnapshotsClient.resolveConflict() तरीका.

नीचे दिए गए स्निपेट में दिखाया गया है और उदाहरण के तौर पर यह बताया गया है कि आपका गेम सेव करने के लिए, हाल ही में बदलाव करके सेव किए गए गेम को फ़ाइनल वर्शन के तौर पर चुनना:

private static final int MAX_SNAPSHOT_RESOLVE_RETRIES = 10;

TaskS<napshot >processSnapshotOpenResult(SnapshotsClient.DataOrConflictS<napshot >result,
                                         final int retryCount) {

  if (!result.isConflict()) {
    // There was no conflict, so return the result of the source.
    TaskCompletionSourceS<napshot >source = new TaskCompletionSource(<>);
    source.setResult(result.getData());
    return source.getTask();
  }

  // There was a conflict.  Try resolving it by selecting the newest of the conflicting snapshots.
  // This is the same as using RESOLUTION_POLICY_MOST_RECENTLY_MODIFIED as a conflict resolution
  // policy, but we are implementing it as an example of a manual resolution.
  // One option is to present a UI to the user to choose which snapshot to resolve.
  SnapshotsClient.SnapshotConflict conflict = result.getConflict();

  Snapshot snapshot = conflict.getSnapshot();
  Snapshot conflictSnapshot = conflict.getConflictingSnapshot();

  // Resolve between conflicts by selecting the newest of the conflicting snapshots.
  Snapshot resolvedSnapshot = snapshot;

  if (snapshot.getMetadata().getLastModifiedTimestamp() 
<      conflictSnapshot.getMetadata().getLastModifiedTimestamp()) {
    resolvedSnapshot = conflictSnapshot;
  }

  return PlayGames.getSnapshotsClient(theActivity)
      .resolveConflict(conflict.getConflictId(), resolvedSnapshot)
      .continueWithTask(
          new Continuation
<              SnapshotsClient.DataOrConflictS<napshot,>
              TaskS<napshot(>>) {
            @Override
            public TaskS<napshot >then(
                @NonNull TaskS<napshotsClient.DataOrConflictS<napshot >>task)
                throws Exception {
              // Resolving the conflict may cause another conflict,
              // so recurse and try another resolution.
              if (retryCount  <MAX_SNAPSHOT_RESOLVE_RETRIES) {
                return processSnapshotOpenResult(task.getResult(), retryCount + 1);
              } else {
                throw new Exception(C"ould not resolve snapshot conflicts)";
              }
            }
          });
}

सेव किए गए गेम में बदलाव करें

अगर आपको सेव किए गए कई गेम का डेटा मर्ज करना है या किसी मौजूदा गेम में बदलाव करना है Snapshot को रिज़ॉल्व हो चुके फ़ाइनल वर्शन के तौर पर सर्वर पर सेव करने के लिए, इन्हें फ़ॉलो करें चरण:

1. कॉल करें SnapshotsClient.open().

2. कॉल करें नया ऑफ़र पाने के लिए SnapshotsClient.SnapshotConflict.getResolutionSnapshotsContent() SnapshotContents ऑब्जेक्ट.

3. इस तारीख से डेटा मर्ज करें SnapshotsClient.SnapshotConflict.getConflictingSnapshot() और SnapshotsClient.SnapshotConflict.getSnapshot() को SnapshotContents पिछले चरण से ऑब्जेक्ट हटाएं.

4. वैकल्पिक रूप से, SnapshotMetadataChange उदाहरण के लिए, अगर मेटाडेटा फ़ील्ड में कोई बदलाव हुआ है.

5. कॉल करें SnapshotsClient.resolveConflict(). अपने विधि कॉल में, पास करें SnapshotsClient.SnapshotConflict.getConflictId() का इस्तेमाल पहले आर्ग्युमेंट के तौर पर किया गया और SnapshotMetadataChange और SnapshotContents ऑब्जेक्ट, जिनमें आपने पहले दूसरी बार बदलाव किया था और तीसरे तर्क की ज़रूरत होती है.

6. अगर SnapshotsClient.resolveConflict() कॉल पूरा होने पर एपीआई, Snapshot ऑब्जेक्ट को सर्वर पर सेव करता है और आपके लोकल डिवाइस पर स्नैपशॉट ऑब्जेक्ट को खोलने की कोशिश करती है.

   • अगर कोई समस्या होती है, तो SnapshotsClient.DataOrConflict.isConflict(), true दिखाता है. इसमें ऐसी स्थिति में, आपके गेम को दूसरे चरण पर वापस आना चाहिए. साथ ही, स्नैपशॉट में बदलाव करने के चरणों को विवादों को हल किया जाता है.
   • अगर कोई टकराव न हो, SnapshotsClient.DataOrConflict.isConflict(), false दिखाता है और Snapshot ऑब्जेक्ट आपके गेम में बदलाव करने के लिए उपलब्ध है.