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

Android गेम में साइन इन करें

Google Play Games Services की सुविधाओं को ऐक्सेस करने के लिए, आपके गेम में साइन इन करने वाले खिलाड़ी का खाता होना चाहिए. अगर खिलाड़ी की पुष्टि नहीं की जाती है, तो Google Play Games Services API को कॉल करते समय आपके गेम में गड़बड़ियां आ सकती हैं. इस दस्तावेज़ में, अपने गेम में आसानी से साइन-इन करने की सुविधा लागू करने का तरीका बताया गया है.

खिलाड़ी के साइन इन करने की सुविधा लागू करना

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

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

नीचे दिए गए कोड स्निपेट में दिखाए गए तरीके से, GoogleSignInOptions ऑब्जेक्ट की मदद से साइन-इन क्लाइंट बनाएं. साइन-इन की प्रोसेस को कॉन्फ़िगर करने के लिए, आपको GoogleSignInOptions.Builder में GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN की जानकारी देनी होगी.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
अगर आपको SnapshotsClient का इस्तेमाल करना है, तो नीचे दिए गए कोड स्निपेट में दिखाए गए तरीके से, GoogleSignInOptions.Builder में .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) जोड़ें:
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
चेतावनी: किसी दूसरे स्कोप या Google प्रोफ़ाइल के डेटा का अनुरोध तब तक न करें, जब तक कि वे आपके इस्तेमाल के उदाहरण के लिए ज़रूरी न हों. किसी भी दूसरे स्कोप की वजह से, पहली बार साइन इन करने पर, साइलेंट साइन इन की सुविधा काम नहीं करती. हालांकि, जिन उपयोगकर्ताओं ने पहले ही किसी दूसरे डिवाइस पर साइन इन कर लिया है उनके लिए यह सुविधा काम करती है.
GoogleSignIn.getClient() तरीके को कॉल करें और उन विकल्पों को पास करें जिन्हें आपने पिछले चरणों में कॉन्फ़िगर किया था. अगर कॉल कामयाब होता है, तो Google Sign-In API, GoogleSignInClient का एक इंस्टेंस दिखाता है.

देखें कि खिलाड़ी ने पहले से साइन इन किया है या नहीं

GoogleSignIn.getLastSignedInAccount() का इस्तेमाल करके, यह देखा जा सकता है कि मौजूदा डिवाइस पर किसी खाते में पहले से साइन इन किया गया है या नहीं. साथ ही, GoogleSignIn.hasPermissions() का इस्तेमाल करके यह भी देखा जा सकता है कि इस खाते के पास ज़रूरी अनुमतियां पहले से हैं या नहीं. अगर दोनों शर्तें पूरी होती हैं, यानी getLastSignedInAccount() से कोई ऐसी वैल्यू मिलती है जो शून्य नहीं है और hasPermissions() से true मिलता है, तो getLastSignedInAccount() से मिले खाते का इस्तेमाल किया जा सकता है. भले ही, डिवाइस ऑफ़लाइन हो.

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

silentSignIn() वाला तरीका, Task<GoogleSignInAccount> दिखाता है. टास्क पूरा होने पर, पहले से तय किए गए GoogleSignInAccount फ़ील्ड को उस साइन इन खाते पर सेट किया जाता है जो टास्क के नतीजे के तौर पर दिखता है. इसके अलावा, इसे null पर भी सेट किया जा सकता है, जिससे पता चलता है कि कोई उपयोगकर्ता साइन इन नहीं है.

अगर साइन इन करने की कोशिश पूरी नहीं होती है, तो साइन इन करने के लिए उपयोगकर्ता इंटरफ़ेस दिखाने के लिए, साइन इन करने का इंटेंट भेजा जा सकता है. इस बारे में ज़्यादा जानने के लिए, इंटरैक्टिव साइन इन करने का तरीका लेख पढ़ें.

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

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

साइन इन करने का साइलेंट फ़्लो शुरू करने के लिए, GoogleSignInClient पर silentSignIn() तरीके को कॉल करें. अगर साइन इन की प्रक्रिया पूरी हो जाती है, तो यह कॉल एक Task<GoogleSignInAccount> ऑब्जेक्ट दिखाता है. इस ऑब्जेक्ट में GoogleSignInAccount होता है.
OnCompleteListener को बदलकर, प्लेयर के साइन इन करने की प्रोसेस के पूरा होने या न होने की जानकारी दें.
- अगर साइन इन करने का टास्क पूरा हो गया है, तो getResult() को कॉल करके GoogleSignInAccount ऑब्जेक्ट पाएं.
- अगर साइन इन नहीं हो पाया है, तो इंटरैक्टिव साइन इन फ़्लो लॉन्च करने के लिए, साइन इन इंटेंट भेजा जा सकता है. इस्तेमाल किए जा सकने वाले अन्य कॉलबैक लिसनर की सूची के लिए, Tasks API डेवलपर गाइड और Task एपीआई रेफ़रंस देखें.

नीचे दिए गए कोड स्निपेट में बताया गया है कि आपका ऐप्लिकेशन, साइलेंट साइन-इन कैसे कर सकता है:

private void signInSilently() {
  GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
  GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
  if (GoogleSignIn.hasPermissions(account, signInOptions.getScopeArray())) {
    // Already signed in.
    // The signed in account is stored in the 'account' variable.
    GoogleSignInAccount signedInAccount = account;
  } else {
    // Haven't been signed-in before. Try the silent sign-in first.
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOptions);
    signInClient
        .silentSignIn()
        .addOnCompleteListener(
            this,
            new OnCompleteListener<GoogleSignInAccount>() {
              @Override
              public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
                if (task.isSuccessful()) {
                  // The signed in account is stored in the task's result.
                  GoogleSignInAccount signedInAccount = task.getResult();
                } else {
                  // Player will need to sign-in explicitly using via UI.
                  // See [sign-in best practices](http://developers.google.com/games/services/checklist) for guidance on how and when to implement Interactive Sign-in,
                  // and [Performing Interactive Sign-in](http://developers.google.com/games/services/android/signin#performing_interactive_sign-in) for details on how to implement
                  // Interactive Sign-in.
                }
              }
            });
  }
}

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

अगर साइन इन करने की कोशिश पूरी नहीं होती है, तो getException() कोड डायल करके, ApiException कोड के साथ स्थिति की पूरी जानकारी पाएं. CommonStatusCodes.SIGN_IN_REQUIRED का स्टेटस कोड यह दिखाता है कि खिलाड़ी को साइन इन करने के लिए साफ़ तौर पर कार्रवाई करनी होगी. इस मामले में, आपके ऐप्लिकेशन को अगले सेक्शन में बताए गए तरीके से, इंटरैक्टिव साइन-इन फ़्लो लॉन्च करना चाहिए.

प्लेयर इंटरैक्शन की मदद से साइन इन करने के लिए, आपके ऐप्लिकेशन को साइन-इन इंटेंट लॉन्च करना होगा. अगर पुष्टि हो जाती है, तो Google Sign-In API एक यूज़र इंटरफ़ेस दिखाता है. इसमें खिलाड़ी को साइन इन करने के लिए, अपने क्रेडेंशियल डालने के लिए कहा जाता है. इस तरीके से, ऐप्लिकेशन डेवलप करना आसान हो जाता है. ऐसा इसलिए, क्योंकि साइन इन करने की गतिविधि, आपके ऐप्लिकेशन की ओर से Google Play services को अपडेट करने या सहमति के अनुरोध दिखाने जैसी स्थितियों को मैनेज करती है. नतीजा, onActivityResult कॉलबैक के ज़रिए दिखाया जाता है.

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

साइन इन करने का इंटेंट पाने के लिए, GoogleSignInClient पर getSigninIntent() को कॉल करें. इसके बाद, startActivity() को कॉल करें और उस इंटेंट को पास करें. नीचे दिए गए कोड स्निपेट में बताया गया है कि आपका ऐप्लिकेशन, इंटरैक्टिव साइन-इन फ़्लो को कैसे लॉन्च कर सकता है:
```
private void startSignInIntent() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}
```
onActivityResult() कॉलबैक में, दिखाए गए इंटेंट के नतीजे को हैंडल करें.
- अगर साइन इन की प्रोसेस पूरी हो गई है, तो GoogleSignInResult से GoogleSignInAccount ऑब्जेक्ट पाएं.
- अगर साइन इन नहीं हो पाया है, तो आपको साइन इन करने से जुड़ी गड़बड़ी को ठीक करना होगा. उदाहरण के लिए, सूचना में गड़बड़ी का मैसेज दिखाकर. नीचे दिया गया कोड स्निपेट दिखाता है कि आपका ऐप्लिकेशन, खिलाड़ी के साइन इन करने के नतीजों को कैसे मैनेज कर सकता है:
```
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode == RC_SIGN_IN) {
    GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
    if (result.isSuccess()) {
      // The signed in account is stored in the result.
      GoogleSignInAccount signedInAccount = result.getSignInAccount();
    } else {
      String message = result.getStatus().getStatusMessage();
      if (message == null || message.isEmpty()) {
        message = getString(R.string.signin_other_error);
      }
      new AlertDialog.Builder(this).setMessage(message)
          .setNeutralButton(android.R.string.ok, null).show();
    }
  }
}
```

खिलाड़ी की जानकारी हासिल करना

Google Sign-In API से मिलने वाले GoogleSignInAccount में, प्लेयर की कोई जानकारी नहीं होती. अगर आपका गेम, खिलाड़ी की जानकारी का इस्तेमाल करता है, जैसे कि खिलाड़ी का डिसप्ले नेम और गेमर आईडी, तो इस जानकारी को वापस पाने के लिए यह तरीका अपनाएं.

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

getPlayersClient() तरीके को कॉल करके, PlayersClient ऑब्जेक्ट पाएं और पैरामीटर के तौर पर GoogleSignInAccount डालें.
Player ऑब्जेक्ट को असिंक्रोनस तरीके से लोड करने के लिए, PlayersClient तरीकों का इस्तेमाल करें. इस ऑब्जेक्ट में खिलाड़ी की जानकारी होती है. उदाहरण के लिए, फ़िलहाल साइन इन किए हुए प्लेयर को लोड करने के लिए, getCurrentPlayer() को कॉल किया जा सकता है. अगर टास्क, SIGN_IN_REQUIRED के स्टेटस कोड के साथ ApiException दिखाता है, तो इसका मतलब है कि प्लेयर की फिर से पुष्टि करनी होगी. ऐसा करने के लिए, प्लेयर में इंटरैक्टिव तरीके से साइन इन करने के लिए, GoogleSignInClient.getSignInIntent() को कॉल करें.
अगर टास्क से Player ऑब्जेक्ट मिलता है, तो खिलाड़ी की खास जानकारी पाने के लिए, Player ऑब्जेक्ट के तरीकों को कॉल किया जा सकता है. उदाहरण के लिए, getDisplayName() या getPlayerId().

अपने गेम में Google का स्टैंडर्ड साइन इन बटन देने के लिए, इनमें से कोई एक तरीका अपनाएं:

मुख्य गतिविधि लेआउट में com.google.android.gms.common.SignInButton शामिल करें या
Google साइन-इन के ब्रैंडिंग दिशा-निर्देशों के मुताबिक, साइन-इन करने के लिए कस्टम बटन डिज़ाइन करें.

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

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

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_sign_in);
  findViewById(R.id.sign_in_button).setOnClickListener(this);
  findViewById(R.id.sign_out_button).setOnClickListener(this);
}

नीचे दिए गए कोड स्निपेट से पता चलता है कि जब उपयोगकर्ता साइन-इन बटन पर क्लिक करता है, तो साइन-इन का इरादा कैसे भेजा जा सकता है.

@Override
public void onClick(View view) {
  if (view.getId() == R.id.sign_in_button) {
    // start the asynchronous sign in flow
    startSignInIntent();
  } else if (view.getId() == R.id.sign_out_button) {
    // sign out.
    signOut();
    // show sign-in button, hide the sign-out button
    findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE);
    findViewById(R.id.sign_out_button).setVisibility(View.GONE);
  }
}

गेम के पॉप-अप दिखाना

GamesClient क्लास का इस्तेमाल करके, अपने गेम में पॉप-अप व्यू दिखाए जा सकते हैं. उदाहरण के लिए, आपका गेम “वेलकम बैक” या “अब तक की उपलब्धियां” पॉप-अप दिखा सकता है. Google Play Games Services को अपने गेम में व्यू में पॉप-अप लॉन्च करने की अनुमति देने के लिए, setViewForPopups() तरीका आज़माएं. setGravityForPopups() को कॉल करके, स्क्रीन पर पॉप-अप के दिखने की जगह को अपनी पसंद के मुताबिक बनाया जा सकता है.

प्लेयर को साइन आउट करना

साइन आउट करने के लिए, GoogleSignInClient पर signOut() तरीके को कॉल करें.

private void signOut() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  signInClient.signOut().addOnCompleteListener(this,
      new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          // at this point, the user is signed out.
        }
      });
}