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

C++ के साथ Google Play गेम सेवाओं का इस्तेमाल करके पुष्टि करें

Android गेम में खिलाड़ियों को साइन इन करने के लिए, Google Play की गेम सेवाओं का इस्तेमाल किया जा सकता है जो Firebase पर बनाया गया है और C++ में लिखा गया है. Google Play Games की सेवाओं का इस्तेमाल करने के लिए, साइन इन करें Firebase की मदद से, सबसे पहले Google Play Games में प्लेयर में साइन इन करें और OAuth 2.0 ऑथराइज़ेशन कोड. इसके बाद, ऑथराइज़ेशन कोड को पास करें Firebase क्रेडेंशियल जनरेट करने के लिए PlayGamesAuthProvider, जिसका इस्तेमाल किया जा सकता है Firebase की मदद से पुष्टि करें.

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

इस्तेमाल करने से पहले Firebase Authentication आपको ये काम करने होंगे:

अपना C++ प्रोजेक्ट रजिस्टर करें और उसे Firebase का इस्तेमाल करने के लिए कॉन्फ़िगर करें.

अगर आपके C++ प्रोजेक्ट में पहले से ही Firebase का इस्तेमाल हो रहा है, तो इसका मतलब है कि वह पहले से रजिस्टर है और Firebase के लिए कॉन्फ़िगर किया गया.
अपने C++ प्रोजेक्ट में Firebase C++ SDK टूल जोड़ें.

ध्यान दें कि Firebase को C++ प्रोजेक्ट में जोड़ने पर, Firebase कंसोल खोलें और अपने खुले हुए C++ प्रोजेक्ट में (उदाहरण के लिए, कंसोल से Firebase कॉन्फ़िगरेशन फ़ाइलें चुनकर, उन्हें अपने C++ प्रोजेक्ट में ले जाएं.

अपना Firebase प्रोजेक्ट सेट अप करना

अगर आपने पहले से अपने गेम का SHA-1 फ़िंगरप्रिंट सेट नहीं किया है, तो सेटिंग पेज Firebase कंसोल का इस्तेमाल किया जा सकता है.

आपको Gradle के साथ अपने साइनिंग सर्टिफ़िकेट का SHA हैश मिल सकता है signingReport निर्देश:
```
./gradlew signingReport
```
साइन इन की सेवा देने वाली कंपनी के तौर पर Google Play Games को चालू करें:
1. Firebase कंसोल में, Authentication सेक्शन.
2. अपने प्रोजेक्ट का वेब सर्वर क्लाइंट आईडी और क्लाइंट जनरेट करें और पाएं सीक्रेट:
  1. साइन इन करने का तरीका टैब में जाकर, Google में साइन इन करने की सुविधा चालू करें कंपनी.
  2. Google साइन इन से वेब सर्वर क्लाइंट आईडी और सीक्रेट को कॉपी करें कंपनी.
3. साइन इन करने का तरीका टैब में, Play Games को चालू करें साइन-इन करने वाली कंपनी को चुनें, और अपने प्रोजेक्ट के वेब सर्वर क्लाइंट आईडी को दर्ज करें और की है, जो आपको आखिरी चरण में मिली थी.

Play Games services को अपने Firebase ऐप्लिकेशन की जानकारी के साथ कॉन्फ़िगर करें

इस Google Play कंसोल, अपना Google Play ऐप्लिकेशन खोलें या नया ऐप्लिकेशन बनाएं.
बढ़ाएं सेक्शन में, Play Games services > सेटअप और मैनेजमेंट > कॉन्फ़िगरेशन.
हां, मेरे गेम में पहले से ही Google API का इस्तेमाल हो रहा है पर क्लिक करें. इसके बाद, अपना Firebase चुनें प्रोजेक्ट चुनें और फिर इस्तेमाल करें पर क्लिक करें.
Play Games services कॉन्फ़िगरेशन पेज पर, क्लिक करें क्रेडेंशियल जोड़ें.
1. गेम सर्वर टाइप चुनें.
2. OAuth क्लाइंट फ़ील्ड में, अपने प्रोजेक्ट का वेब क्लाइंट आईडी चुनें. होना पक्का करें कि यह वही क्लाइंट आईडी है जिसे आपने चालू करते समय तय किया था Play Games साइन इन.
3. बदलावों को सेव करें.
अब भी Play Games services कॉन्फ़िगरेशन पेज पर, क्लिक करें फिर से क्रेडेंशियल जोड़ें.
1. Android टाइप चुनें.
2. OAuth क्लाइंट फ़ील्ड में, अपने प्रोजेक्ट का Android क्लाइंट आईडी चुनें. (अगर आपको अपना Android क्लाइंट आईडी नहीं दिखता है, तो अपने गेम के Firebase कंसोल में SHA-1 फ़िंगरप्रिंट.)
3. बदलावों को सेव करें.
टेस्टर पेज पर, ऐसे किसी भी उपयोगकर्ता के ईमेल पते जोड़ें जिसे आप गेम को Play वाले ऐप्लिकेशन पर रिलीज़ करने से पहले उसमें साइन इन कर सकें Play Store.

अपने गेम में, Play Games में साइन इन करने की सुविधा इंटिग्रेट करें

खिलाड़ियों को अपने गेम में साइन इन करने से पहले, Google Play को इंटिग्रेट करना होगा गेम में साइन इन.

C++ में, Play Games में साइन इन करने के लिए, सहायता जोड़ने का सबसे आसान और सुझाया गया तरीका Android प्रोजेक्ट में, 'Google साइन इन' C++ SDK टूल का इस्तेमाल किया जाना है.

Google साइन इन C++ SDK टूल का इस्तेमाल करके, अपने गेम में Play Games में साइन इन करने के लिए यह तरीका अपनाएं फ़ॉलो किया जा रहा है:

'Google साइन-इन' Unity प्लगिन का डेटा स्टोर करने की जगह का क्लोन बनाएं या डाउनलोड करें, इसमें C++ SDK टूल भी शामिल है.
staging/native/ डायरेक्ट्री में मौजूद प्रोजेक्ट बनाएं. इसके लिए, इनमें से किसी का भी इस्तेमाल किया जा सकता है Android Studio या gradlew build.

बिल्ड अपने आउटपुट को google-signin-cpp नाम की डायरेक्ट्री में कॉपी करता है.

अपने गेम के नेटिव कोड में, 'Google साइन इन C++ SDK टूल' शामिल करें और फ़ाइल बनाने का तरीका जानें:

सीमेक

आपकी टॉप-लेवल CMakeLists.txt फ़ाइल में:

set(GSI_PACKAGE_DIR "/path/to/google-signin-cpp")

add_library(lib-google-signin-cpp STATIC IMPORTED)
set_target_properties(lib-google-signin-cpp PROPERTIES IMPORTED_LOCATION
    ${GSI_PACKAGE_DIR}/lib/${ANDROID_ABI}/libgoogle-signin-cpp.a )

...

target_link_libraries(
    ...
    lib-google-signin-cpp)

एनडीके-बिल्ड

आपकी Android.mk फ़ाइल में:

include $(CLEAR_VARS)
LOCAL_MODULE := google-signin-cpp
GSI_SDK_DIR := /path/to/google-signin-cpp
LOCAL_SRC_FILES := $(GSI_SDK_DIR)/lib/$(TARGET_ARCH_ABI)/libgoogle-signin-cpp.a
LOCAL_EXPORT_C_INCLUDES := $(GSI_SDK_DIR)/include
include $(PREBUILT_STATIC_LIBRARY)

इसके बाद, Java हेल्पर कॉम्पोनेंट शामिल करें, जो C++ SDK टूल के लिए ज़रूरी है.

ऐसा करने के लिए, अपनी प्रोजेक्ट-लेवल की build.gradle फ़ाइल में, SDK टूल का बिल्ड जोड़ें लोकल रिपॉज़िटरी के तौर पर आउटपुट डायरेक्ट्री:
```
allprojects {
    repositories {
        // ...
        flatDir {
            dirs 'path/to/google-signin-cpp'
        }
    }
}
```
इसके अलावा, अपनी मॉड्यूल-लेवल build.gradle फ़ाइल में, हेल्पर कॉम्पोनेंट का एलान करें डिपेंडेंसी के तौर पर:
```
dependencies {
    implementation 'com.google.android.gms:play-services-auth:21.2.0'
    // Depend on the AAR built with the Google Sign-in SDK in order to add
    // the Java helper classes, which are used by the C++ library.
    compile(name:'google-signin-cpp-release', ext:'aar')
}
```

इसके बाद, Play Games का इस्तेमाल करने के लिए, अपने गेम में GoogleSignIn ऑब्जेक्ट को कॉन्फ़िगर करें साइन-इन करें और सर्वर का ऑथराइज़ेशन कोड वापस पाने के लिए:

#include "google_signin.h"
#include "future.h"

using namespace google::signin;

// ...

GoogleSignIn::Configuration config = {};
config.web_client_id = "YOUR_WEB_CLIENT_ID_HERE";
config.request_id_token = false;
config.use_game_signin = true;
config.request_auth_code = true;

GoogleSignIn gsi = GoogleSignIn(GetActivity(), GetJavaVM());
gsi.Configure(config);

आखिर में, Play Games में खिलाड़ी को साइन इन कराने के लिए SignIn() को कॉल करें:

Future<GoogleSignIn::SignInResult> &future = gsi.SignIn();

SignIn() से मिलने वाली गड़बड़ी ठीक होने पर, आपको सर्वर से पुष्टि की जानकारी मिल सकती है कोड खोजें:

if (!future.Pending()) {
    const GoogleSignIn::StatusCode status =
            static_cast<GoogleSignIn::StatusCode>(future.Status());
    if (status == GoogleSignIn::kStatusCodeSuccess) {
        // Player successfully signed in to Google Play! Get auth code to
        //   pass to Firebase
        const GoogleSignIn::SignInResult result =
                static_cast<GoogleSignIn::SignInResult>(future.Result());
        const char* server_auth_code = result.User.GetServerAuthCode();
    }
}

Firebase की मदद से पुष्टि करें

जब खिलाड़ी Play Games से साइन इन कर लेता है, तब पुष्टि करने वाले कोड का इस्तेमाल इन कामों के लिए किया जा सकता है Firebase की मदद से पुष्टि करें.

जब खिलाड़ी Play Games का इस्तेमाल करके साइन इन कर ले, तब पुष्टि करें प्लेयर के खाते के लिए कोड डालें.
इसके बाद, Play की गेम सेवाओं से मिले ऑथराइज़ेशन कोड को Firebase के लिए बदलें क्रेडेंशियल पर जाएं और प्लेयर की पुष्टि करने के लिए Firebase क्रेडेंशियल का इस्तेमाल करें:
```
firebase::auth::Credential credential =
    firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);
```
अगर आपके प्रोग्राम में एक अपडेट लूप है, जो नियमित रूप से चलता है (जैसे 30 या 60 पर बार प्रति सेकंड), तो आप इसकी मदद से हर अपडेट के लिए एक बार नतीजे देख सकते हैं Auth::SignInAndRetrieveDataWithCredentialLastResult:
```
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredentialLastResult();
if (result.status() == firebase::kFutureStatusComplete) {
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::AuthResult auth_result = *result.result();
    printf("Sign in succeeded for `%s`\n",
           auth_result.user.display_name().c_str());
  } else {
    printf("Sign in failed with error '%s'\n", result.error_message());
  }
}
```
इसके अलावा, अगर आपका प्रोग्राम इवेंट के आधार पर चलाया जाता है, तो आने वाले समय में कॉलबैक रजिस्टर करें.

फ़्यूचर के लिए कॉलबैक रजिस्टर करना

कुछ प्रोग्राम में Update फ़ंक्शन होते हैं, जिन्हें प्रति सेकंड 30 या 60 बार कॉल किया जाता है. उदाहरण के लिए, कई गेम इस मॉडल का पालन करते हैं. ये प्रोग्राम, LastResult को कॉल कर सकते हैं फ़ंक्शन का इस्तेमाल करें. हालांकि, अगर आपका प्रोग्राम इवेंट के आधार पर तय होता है, तो आपके पास कॉलबैक फ़ंक्शन को रजिस्टर करने का विकल्प होता है. फ़्यूचर के पूरा होने पर कॉलबैक फ़ंक्शन को कॉल किया जाता है.

void OnCreateCallback(const firebase::Future<firebase::auth::User*>& result,
                      void* user_data) {
  // The callback is called when the Future enters the `complete` state.
  assert(result.status() == firebase::kFutureStatusComplete);

  // Use `user_data` to pass-in program context, if you like.
  MyProgramContext* program_context = static_cast<MyProgramContext*>(user_data);

  // Important to handle both success and failure situations.
  if (result.error() == firebase::auth::kAuthErrorNone) {
    firebase::auth::User* user = *result.result();
    printf("Create user succeeded for email %s\n", user->email().c_str());

    // Perform other actions on User, if you like.
    firebase::auth::User::UserProfile profile;
    profile.display_name = program_context->display_name;
    user->UpdateUserProfile(profile);

  } else {
    printf("Created user failed with error '%s'\n", result.error_message());
  }
}

void CreateUser(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // `&my_program_context` is passed verbatim to OnCreateCallback().
  result.OnCompletion(OnCreateCallback, &my_program_context);
}

अगर आप चाहें, तो कॉलबैक फ़ंक्शन को लैम्डा भी किया जा सकता है.

void CreateUserUsingLambda(firebase::auth::Auth* auth) {
  // Callbacks work the same for any firebase::Future.
  firebase::Future<firebase::auth::AuthResult> result =
      auth->CreateUserWithEmailAndPasswordLastResult();

  // The lambda has the same signature as the callback function.
  result.OnCompletion(
      [](const firebase::Future<firebase::auth::User*>& result,
         void* user_data) {
        // `user_data` is the same as &my_program_context, below.
        // Note that we can't capture this value in the [] because std::function
        // is not supported by our minimum compiler spec (which is pre C++11).
        MyProgramContext* program_context =
            static_cast<MyProgramContext*>(user_data);

        // Process create user result...
        (void)program_context;
      },
      &my_program_context);
}

अगले चरण

किसी उपयोगकर्ता के पहली बार साइन इन करने के बाद, एक नया उपयोगकर्ता खाता बना दिया जाता है और लिंक किया गया हो. यह नया खाता आपके Firebase प्रोजेक्ट बनाया जा सकता है. इसकी मदद से, आपके ऐप्लिकेशन में मौजूद हर ऐप्लिकेशन पर उपयोगकर्ता की पहचान की जा सकती है प्रोजेक्ट.

अपने गेम में, उपयोगकर्ता का Firebase यूआईडी firebase::auth::User ऑब्जेक्ट:

firebase::auth::User user = auth->current_user();
if (user.is_valid()) {
  std::string playerName = user.displayName();

  // The user's ID, unique to the Firebase project.
  // Do NOT use this value to authenticate with your backend server,
  // if you have one. Use firebase::auth::User::Token() instead.
  std::string uid = user.uid();
}

अपने Firebase रीयल टाइम डेटाबेस और Cloud Storage के सुरक्षा नियमों में, आपको ये चीज़ें मिल सकती हैं auth वैरिएबल से साइन-इन किए हुए उपयोगकर्ता का यूनीक यूज़र आईडी. साथ ही, इसका इस्तेमाल इन कामों के लिए करें तय करें कि उपयोगकर्ता कौनसा डेटा ऐक्सेस कर सकता है.

उपयोगकर्ता के Play Games खिलाड़ी की जानकारी पाने या Play Games की सेवाएं ऐक्सेस करने के लिए, Google Play की गेम सेवाओं के C++ SDK टूल से मिले एपीआई का इस्तेमाल करना होगा.

किसी उपयोगकर्ता को साइन आउट करने के लिए, SignOut() पर कॉल करें:

auth->SignOut();