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

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

वेब कंटेनर इंस्टॉल करने से पहले

Firebase से पुष्टि करने की सुविधा का इस्तेमाल करने से पहले, आपको:

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

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

  • अपने C++ प्रोजेक्ट में Firebase C++ SDK टूल जोड़ें.

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

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

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

    Gradle signingReport कमांड का इस्तेमाल करके, अपने साइनिंग सर्टिफ़िकेट का SHA हैश पाया जा सकता है: 

    ./gradlew signingReport

  2. Google Play Games को साइन इन की सेवा देने वाली कंपनी के तौर पर चालू करें:

    1. Firebase कंसोल में, पुष्टि करने की सुविधा सेक्शन खोलें.

    2. अपने प्रोजेक्ट का वेब सर्वर क्लाइंट आईडी और क्लाइंट सीक्रेट जनरेट करें और पाएं:

      1. साइन इन करने का तरीका टैब में, Google साइन इन करने की सेवा देने वाली कंपनी को चालू करें.

      2. Google साइन इन करने वाली कंपनी से वेब सर्वर क्लाइंट आईडी और सीक्रेट कॉपी करें.

    3. साइन इन करने का तरीका टैब में, Play Games में साइन-इन करने की सेवा देने वाली कंपनी को चालू करें. इसके बाद, अपने प्रोजेक्ट के वेब सर्वर क्लाइंट आईडी और क्लाइंट सीक्रेट की जानकारी दें, जो आपको आखिरी चरण में मिला था.

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

  1. Google Play Console में जाकर, अपना Google Play ऐप्लिकेशन खोलें या नया ऐप्लिकेशन बनाएं.

  2. बढ़ाएं सेक्शन में जाकर, Play की गेम सेवाएं > सेटअप और मैनेजमेंट > कॉन्फ़िगरेशन पर क्लिक करें.

  3. हां, मेरे गेम में पहले से ही Google API का इस्तेमाल हो रहा है पर क्लिक करें. इसके बाद, सूची से अपना Firebase प्रोजेक्ट चुनें और इस्तेमाल करें पर क्लिक करें.

  4. Play की गेम सेवाओं के कॉन्फ़िगरेशन पेज पर, क्रेडेंशियल जोड़ें पर क्लिक करें.

    1. गेम सर्वर टाइप चुनें.
    2. OAuth क्लाइंट फ़ील्ड में, अपने प्रोजेक्ट का वेब क्लाइंट आईडी चुनें. पक्का करें कि यह वही क्लाइंट आईडी है जिसे आपने Play Games में साइन इन करने की सुविधा चालू करते समय डाला था.
    3. बदलावों को सेव करें.

  5. अब भी Play की गेम सेवाओं के कॉन्फ़िगरेशन पेज पर जाकर, क्रेडेंशियल जोड़ें पर फिर से क्लिक करें.

    1. Android टाइप चुनें.
    2. OAuth क्लाइंट फ़ील्ड में, अपने प्रोजेक्ट का Android क्लाइंट आईडी चुनें. (अगर आपको अपना Android क्लाइंट आईडी नहीं दिखता है, तो पक्का करें कि आपने Firebase कंसोल में अपने गेम का SHA-1 फ़िंगरप्रिंट सेट किया हो.)
    3. बदलावों को सेव करें.

  6. टेस्टर पेज पर, उन सभी उपयोगकर्ताओं के ईमेल पते जोड़ें जो Play Store पर गेम को रिलीज़ करने से पहले उसमें साइन इन करना चाहते हैं.

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

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

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

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

  1. 'Google साइन-इन' Unity प्लगिन का डेटा स्टोर करने की जगह का क्लोन बनाएं या डाउनलोड करें. इसमें C++ SDK टूल भी शामिल है.

  2. या तो Android Studio या gradlew build का इस्तेमाल करके, staging/native/ डायरेक्ट्री में मौजूद प्रोजेक्ट बनाएं.

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

  3. अपने गेम के नेटिव कोड में, '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)

  4. इसके बाद, 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')
}

  5. इसके बाद, अपने गेम में GoogleSignIn ऑब्जेक्ट को कॉन्फ़िगर करें, ताकि Play Games में साइन इन करने की सुविधा का इस्तेमाल किया जा सके और सर्वर से पुष्टि करने वाला कोड फिर से पाया जा सके:

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

  6. आखिर में, 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 से पुष्टि करने के लिए, पुष्टि करने वाले कोड का इस्तेमाल किया जा सकता है.

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

  2. इसके बाद, Play Games सेवाओं से मिले ऑथराइज़ेशन कोड को Firebase क्रेडेंशियल के लिए एक्सचेंज करें और खिलाड़ी की पुष्टि करने के लिए Firebase क्रेडेंशियल का इस्तेमाल करें:

    firebase::auth::Credential credential =
    firebase::auth::PlayGamesAuthProvider::GetCredential(server_auth_code);
firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInAndRetrieveDataWithCredential(credential);

  3. अगर आपके प्रोग्राम में कोई अपडेट लूप है, जो नियमित रूप से चलता है (जैसे कि 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);
}

अगले चरण

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

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

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 की गेम सेवाएं ऐक्सेस करने के लिए, Google Play Games services C++ SDK टूल से मिले एपीआई इस्तेमाल करें.

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

auth->SignOut();