Play Games Services v2 (Unity) पर माइग्रेट करना

इस दस्तावेज़ में, मौजूदा गेम को Games v1 SDK से Games v2 SDK पर माइग्रेट करने का तरीका बताया गया है. Unity के लिए Play Games प्लगिन के वर्शन 10 और इससे पहले के वर्शन, Games v1 SDK का इस्तेमाल करते हैं.

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

• पक्का करें कि आपने Play Console को पहले ही सेट अप कर लिया हो और Unity Editor इंस्टॉल कर लिया हो.

Unity के लिए Google Play Games प्लगिन डाउनलोड करना

Play की गेम सेवाओं की नई सुविधाओं का फ़ायदा पाने के लिए, प्लगिन का नया वर्शन डाउनलोड और इंस्टॉल करें. इसे gitHub डेटाबेस से डाउनलोड करें.

पुराना प्लगिन हटाना

Unity Editor में, ये फ़ोल्डर या फ़ाइलें हटाएं.

Assets/GooglePlayGames

Assets/GeneratedLocalRepo/GooglePlayGames

Assets/Plugins/Android/GooglePlayGamesManifest.androidlib

Assets/Plugins/Android

अपने Unity प्रोजेक्ट में नए प्लगिन को इंपोर्ट करना

अपने Unity प्रोजेक्ट में प्लगिन को इंपोर्ट करने के लिए, यह तरीका अपनाएं:

1. अपने गेम प्रोजेक्ट को खोलें.
2. डाउनलोड की गई फ़ाइल को अपने प्रोजेक्ट की ऐसेट में इंपोर्ट करने के लिए, Unity Editor में Assets > Import Package > Custom Package unitypackage पर क्लिक करें.

3. पक्का करें कि आपका मौजूदा बिल्ड प्लैटफ़ॉर्म Android पर सेट हो.

   1. मुख्य मेन्यू में, File > Build Settings पर क्लिक करें.

   2. Android को चुनें और Switch Platform पर क्लिक करें.

   3. Window > Google Play Games में एक नया मेन्यू आइटम दिखेगा. ऐसा न होने पर, Assets > Refresh पर क्लिक करके ऐसेट रीफ़्रेश करें. इसके बाद, बिल्ड प्लैटफ़ॉर्म को फिर से सेट करने की कोशिश करें.

4. Unity Editor में, File > Build Settings > Player Settings > Other Settings पर क्लिक करें.

5. टारगेट एपीआई लेवल बॉक्स में, कोई वर्शन चुनें.

6. Scripting backend बॉक्स में, IL2CPP डालें.

7. Target architectures बॉक्स में, कोई वैल्यू चुनें.

8. पैकेज का नाम package_name नोट करें. इस जानकारी का इस्तेमाल बाद में किया जा सकता है.

   

9. Play Console से Android के संसाधनों को कॉपी करना

10. अपने Unity प्रोजेक्ट में Android रिसॉर्स जोड़ना

माइग्रेशन के पाथ

आपके गेम के लिए माइग्रेशन का सही पाथ, इस बात पर निर्भर करता है कि वह Play की गेम सेवाओं के वर्शन 1 को कैसे लागू करता है और खिलाड़ी की पहचान को कैसे मैनेज करता है. माइग्रेशन को आसानी से पूरा करने और प्लेयर का डेटा खोने से बचाने के लिए, वह परिदृश्य चुनें जो आपके मौजूदा सेटअप से सबसे ज़्यादा मेल खाता हो. इसके बाद, उससे जुड़े चरण पूरे करें.

पहला विकल्प: उन गेम के लिए जिनमें IGA, Play की गेम सेवाओं की प्लेयर आईडी से जुड़ा है

यह परिदृश्य उन गेम पर लागू होता है जिनमें Play Games की सेवाओं की Player ID का इस्तेमाल, प्लेयर के इन-गेम खाते (आईजीए) के लिए सिर्फ़ एक आइडेंटिफ़ायर के तौर पर किया गया है. साथ ही, जिनमें पहले OpenID का अनुरोध नहीं किया गया है या उसे सेव नहीं किया गया है. इसमें मुख्य चुनौती, मौजूदा आईजीए को प्राइमरी आइडेंटिफ़ायर (OpenID) से लिंक करना है. साथ ही, यह पक्का करना है कि प्लेयर की प्रोग्रेस का डेटा न खोए.

माइग्रेशन के फ़्लो में ये चरण शामिल हैं:

1. गेम लॉन्च होने पर, Play की गेम सेवाओं का वर्शन 2 का एसडीके, प्लैटफ़ॉर्म को अपने-आप और बैकग्राउंड में ऑथेंटिकेट करता है.

2. गेम, अपनी लॉगिन स्क्रीन दिखाता है. इस स्क्रीन पर, Google से साइन इन करें (SiWG) बटन होना चाहिए. यह बटन, Google Play बटन की जगह लेता है. इंटिग्रेट करने के लिए:

   1. CredManBridge.java को अपने फ़ोल्डर में डाउनलोड करें. यह Java क्लास, Unity और androidx.credentials लाइब्रेरी के बीच एक पुल की तरह काम करती है.

      CredManBridge.java

      
      package com.wickedcube.trivialkart;
      import android.accounts.Account;
      import android.content.Context;
      import android.util.Log;
      import android.os.CancellationSignal;
      import androidx.credentials.CredentialManager;
      import androidx.credentials.GetCredentialRequest;
      import androidx.credentials.GetCredentialResponse;
      import androidx.credentials.exceptions.GetCredentialException;
      import androidx.credentials.exceptions.NoCredentialException;
      import com.google.android.libraries.identity.googleid.GetGoogleIdOption;
      import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential;
      import com.google.android.gms.auth.api.identity.AuthorizationClient;
      import com.google.android.gms.auth.api.identity.AuthorizationRequest;
      import com.google.android.gms.auth.api.identity.AuthorizationResult;
      import com.google.android.gms.common.api.ApiException;
      import com.google.android.gms.auth.api.identity.Identity;
      import com.google.android.gms.common.api.Scope;
      import com.unity3d.player.UnityPlayer;
      import java.util.Collections;
      import java.util.List;
      import java.util.concurrent.Executor;
      import java.util.concurrent.Executors;
      
      
      public class CredManBridge {
      
      // --- MODE 1: SILENT SIGN-IN (Called on Awake) ---
      // Tries to auto-select an authorized account. If it fails, it does NOT show UI.
      public static void signInSilent(Context context, String webClientId) {
        CredentialManager credentialManager = CredentialManager.create(context);
        CancellationSignal cancellationSignal = new CancellationSignal();
        Executor executor = Executors.newSingleThreadExecutor();
      
      Log.d("CredMan", "Attempting Silent Sign-In...");
      
      GetGoogleIdOption silentOption = new GetGoogleIdOption.Builder()
          .setFilterByAuthorizedAccounts(true) // Strict: Only authorized accounts
          .setServerClientId(webClientId)
          .setAutoSelectEnabled(true)          // Auto-select if possible
          .build();
      
      GetCredentialRequest silentRequest = new GetCredentialRequest.Builder()
          .addCredentialOption(silentOption)
          .build();
      
      credentialManager.getCredentialAsync(
          context,
          silentRequest,
          cancellationSignal,
          executor,
          new androidx.credentials.CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() {
              @Override
              public void onResult(GetCredentialResponse result) {
                  Log.d("CredMan", "Silent Sign-In Successful!");
                  handleSignInResult(context, result, webClientId);
              }
          @Override
          public void onError(GetCredentialException e) {
              // Send a specific error code so Unity knows to just stay on the Start Screen
              Log.d("CredMan", "Silent sign-in failed. Keeping UI hidden.");
              UnityPlayer.UnitySendMessage("AuthManager", "OnSignInError", "SilentFailed");
          }
      }
      
      );
      }
      
      // --- MODE 2: INTERACTIVE SIGN-IN (Called on Button Click) ---
      // Forces the Account Selection / "Add Account" sheet to appear.
      public static void signInInteractive(Context context, String webClientId) {
        CredentialManager credentialManager = CredentialManager.create(context);
        CancellationSignal cancellationSignal = new CancellationSignal();
        Executor executor = Executors.newSingleThreadExecutor();
      
      Log.d("CredMan", "Starting Interactive Sign-In...");
      
      GetGoogleIdOption interactiveOption = new GetGoogleIdOption.Builder()
          .setFilterByAuthorizedAccounts(false) // Show ALL accounts (and "Add Account")
          .setServerClientId(webClientId)
          .setAutoSelectEnabled(false)          // Force the UI to show
          .build();
      
      GetCredentialRequest interactiveRequest = new GetCredentialRequest.Builder()
          .addCredentialOption(interactiveOption)
          .build();
      
      credentialManager.getCredentialAsync(
          context,
          interactiveRequest,
          cancellationSignal,
          executor,
          new androidx.credentials.CredentialManagerCallback<getcredentialresponse, getcredentialexception="">() {
              @Override
              public void onResult(GetCredentialResponse result) {
                  Log.d("CredMan", "Interactive Sign-In Successful!");
                  handleSignInResult(context, result, webClientId);
              }</getcredentialresponse,>
          @Override
          public void onError(GetCredentialException e) {
              Log.e("CredMan", "Interactive Sign-In Canceled or Failed", e);
              UnityPlayer.UnitySendMessage("AuthManager", "OnSignInError", "Canceled");
          }
      }
      
      );
      }
      
      private static void handleSignInResult(Context context, GetCredentialResponse result, String webClientId) {
        try {
          GoogleIdTokenCredential credential = GoogleIdTokenCredential.createFrom(result.getCredential().getData());
          String email = credential.getId();
      Account account = new Account(email, "com.google");
      // Requesting GAMES_LITE scope to check for pre-existing V1 grants
      List<Scope> requestedScopes = Collections.singletonList(new Scope("https://www.googleapis.com/auth/games_lite"));
      
      AuthorizationRequest authRequest = new AuthorizationRequest.Builder()
          .setRequestedScopes(requestedScopes)
          .setAccount(account)
          .requestOfflineAccess(webClientId)
          .build();
      
      AuthorizationClient authClient = Identity.getAuthorizationClient(context);
      
      authClient.authorize(authRequest)
          .addOnSuccessListener(authorizationResult -> {
              if (authorizationResult.getServerAuthCode() != null) {
                  // CASE 1: RETURNING USER (Success)
                  // The user has already granted GAMES_LITE in the past.
                  // We got the code directly without showing UI.
                  Log.i("CredMan", "PGS v1: Existing grant found. Returning user detected. Auth Code retrieved.");
                  UnityPlayer.UnitySendMessage("AuthManager", "OnSignInSuccess", authorizationResult.getServerAuthCode());
              }
              else if (authorizationResult.hasResolution()) {
                  // CASE 2: NEW USER (PendingIntent)
                  // The user has NOT granted GAMES_LITE before. The API returned a PendingIntent
                  // (authorizationResult.getPendingIntent()) to show the consent screen.
                  // As per your flow, we DISCARD this intent and do not show UI.
                  Log.i("CredMan", "PGS v1: No existing grant (PendingIntent returned). This is a NEW user or they revoked access.");
                  Log.i("CredMan", "PGS v1: Discarding PendingIntent. Proceeding as New User.");
      
                  // Notify Unity that this is a "New User" so it can trigger V2 logic instead of failing
                  UnityPlayer.UnitySendMessage("AuthManager", "OnSignInError", "NewUser_NoGrant");
              }
              else {
                  // Edge Case: No code and no resolution?
                  Log.e("CredMan", "PGS v1: Authorization success but no Auth Code or Resolution returned.");
                  UnityPlayer.UnitySendMessage("AuthManager", "OnSignInError", "No Auth Code returned");
              }
          })
          .addOnFailureListener(e -> {
              // CASE 3: GENERIC FAILURE
              Log.e("CredMan", "PGS v1: Authorization failed completely.", e);
              UnityPlayer.UnitySendMessage("AuthManager", "OnSignInError", "Authorization Failed: " + e.getMessage());
          });
      
      } catch (Exception e) {
          UnityPlayer.UnitySendMessage("AuthManager", "OnSignInError", "Parsing Error: " + e.getMessage());
      }
      }
      }
      
      
      
      

   2. क्रेडेंशियल मैनेजर का इंटिग्रेशन:

      • साइलेंट साइन-इन के लिए, GetGoogleIdOption के साथ setFilterByAuthorizedAccounts(true) का इस्तेमाल करें. इससे सिर्फ़ वे उपयोगकर्ता साइन इन कर पाएंगे जिन्होंने पहले ऐप्लिकेशन को अनुमति दी है.
      • इंटरैक्टिव साइन-इन के लिए, setFilterByAuthorizedAccounts(false) का इस्तेमाल करें. इससे उपयोगकर्ता कोई खाता चुन सकेंगे या नया खाता जोड़ सकेंगे.

   3. स्कोप का अनुरोध:

      • Google के क्रेडेंशियल पाने के बाद, यह AuthorizationRequest बनाता है. इसमें, लेगसी स्कोप का अनुरोध किया जाता है: https://www.googleapis.com/auth/games_lite.
      • यह स्कोप ज़रूरी है, क्योंकि इससे सर्वर को उपयोगकर्ता की लेगसी PlayerID देखने की अनुमति मिलती है.

   4. नतीजे को मैनेज करना:

      • अगर उपयोगकर्ता अनुमति देता है (या उसने पहले अनुमति दी है), तो ब्रिज, ServerAuthCode को Unity पर वापस भेजता है.
      • अगर उपयोगकर्ता ने अनुमति नहीं दी है (नए उपयोगकर्ता का परिदृश्य), तो एपीआई, PendingIntent दिखाता है. इस सैंपल में, इंटेंट को खारिज कर दिया जाता है और उपयोगकर्ता को नए उपयोगकर्ता के तौर पर माना जाता है, ताकि फ़्लो को आसान बनाया जा सके.

3. Credential Manager और Google Identity Services की सेवाओं के साथ काम करने के लिए, पक्का करें कि आपके mainTemplate.gradle gradle कॉन्फ़िगरेशन में ये डिपेंडेंसी जोड़ी गई हों.

   dependencies {
   // Standard Unity dependencies
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   
   // Credential Manager and Identity Libraries
   implementation 'androidx.credentials:credentials:1.3.0'
   implementation 'androidx.credentials:credentials-play-services-auth:1.3.0'
   implementation 'com.google.android.libraries.identity.googleid:googleid:1.1.1'
   
   // Play Services Auth for legacy scope handling
   implementation 'com.google.android.gms:play-services-auth:21.2.0'
   }

   • क्रेडेंशियल मैनेजर: यह खाता चुनने के लिए, मुख्य आइडेंटिटी ऑर्केस्ट्रेशन और यूज़र इंटरफ़ेस (यूआई) को मैनेज करता है.
   • GoogleID लाइब्रेरी: यह खास तौर पर, OpenID Connect टोकन वापस पाने के लिए, GetGoogleIdOption उपलब्ध कराती है.
   • Play सेवाएं पुष्टिकरण: यह कंपैटिबिलिटी बनाए रखने और लेगसी Player ID वापस पाने के लिए, GAMES_LITE स्कोप का अनुरोध करने के लिए ज़रूरी है.

4. जब प्लेयर, SiWG बटन पर टैप करता है और कोई Google खाता चुनता है, तो गेम को दो अलग-अलग आइडेंटिफ़ायर वापस पाने होंगे:

   • OpenID, आईजीए को बाइंड करने के लिए प्राइमरी आइडेंटिफ़ायर.
   • Play की गेम सेवाओं की Player ID. इसे GAMES_LITE स्कोप का इस्तेमाल करके वापस पाया जाता है. इसकी मदद से, आपके बैकएंड सिस्टम में खिलाड़ी का आईजीए देखा जाता है और बाइंडिंग की जाती है.

5. इसके बाद, गेम लॉन्च होने पर, प्लेयर SiWG फ़्लो की मदद से अपने आईजीए को ऐक्सेस कर सकते हैं. इसके लिए, गेम को Player ID का इस्तेमाल प्राइमरी आइडेंटिफ़ायर के तौर पर करने की ज़रूरत नहीं होती.

using GooglePlayGames;
using GooglePlayGames.BasicApi;
using UnityEngine.SocialPlatforms;

public void Start() {
    PlayGamesClientConfiguration config =
        new PlayGamesClientConfiguration.Builder()
    // Enables saving game progress
    .EnableSavedGames()
    // Requests the email address of the player be available
    // will bring up a prompt for consent
    .RequestEmail()
    // Requests a server auth code be generated so it can be passed to an
    // associated backend server application and exchanged for an OAuth token
    .RequestServerAuthCode(false)
    // Requests an ID token be generated. This OAuth token can be used to
    // identify the player to other services such as Firebase.
    .RequestIdToken()
    .Build();

    PlayGamesPlatform.InitializeInstance(config);
    // recommended for debugging:
    PlayGamesPlatform.DebugLogEnabled = true;
    // Activate the Google Play Games platform
    PlayGamesPlatform.Activate();
}

using GooglePlayGames;

public void Start() {
    PlayGamesPlatform.Instance.Authenticate(ProcessAuthentication);
}

internal void ProcessAuthentication(SignInStatus status) {
    if (status == SignInStatus.Success) {
        // Continue with Play Games Services
    } else {
        // Disable your integration with Play Games Services or show a login
        // button to ask users to sign-in. Clicking it should call
        // PlayGamesPlatform.Instance.ManuallyAuthenticate(ProcessAuthentication).
    }
}

// sign out
PlayGamesPlatform.Instance.SignOut();