Migrer vers les services de jeux Play v2 (Unity)

Ce document explique comment migrer des jeux existants du SDK games v1 vers le SDK games v2. Le plug-in Play Jeux pour Unity, versions 10 et antérieures, utilise le SDK v1 de Jeux.

Avant de commencer

• Assurez-vous d'avoir déjà configuré la Play Console et installé l'éditeur Unity.

Télécharger le plug-in Google Play Jeux pour Unity

Pour bénéficier des dernières fonctionnalités des services Play Jeux, téléchargez et installez la dernière version du plug-in. Téléchargez-le depuis le dépôt GitHub.

Supprimer l'ancien plug-in

Dans l'éditeur Unity, supprimez les dossiers ou fichiers suivants.

Assets/GooglePlayGames

Assets/GeneratedLocalRepo/GooglePlayGames

Assets/Plugins/Android/GooglePlayGamesManifest.androidlib

Assets/Plugins/Android

Importer le nouveau plug-in dans votre projet Unity

Pour importer le plug-in dans votre projet Unity, procédez comme suit :

1. Ouvrez votre projet de jeu.
2. Dans l'éditeur Unity, cliquez sur Assets > Import Package > Custom Package (Éléments > Importer un package > Package personnalisé) pour importer le fichier unitypackage téléchargé dans les éléments de votre projet.

3. Assurez-vous que votre plate-forme de compilation actuelle est définie sur Android.

   1. Dans le menu principal, cliquez sur File > Build Settings (Fichier > Paramètres de compilation).

   2. Sélectionnez Android, puis cliquez sur Switch Platform (Changer de plate-forme).

   3. Vous devriez voir un nouvel élément de menu sous Window > Google Play Games (Fenêtre > Google Play Jeux). Si ce n'est pas le cas, actualisez les éléments en cliquant sur Assets > Refresh (Assets > Actualiser), puis réessayez de définir la plate-forme de compilation.

4. Dans l'éditeur Unity, cliquez sur File > Build Settings > Player Settings > Other Settings (Fichier > Paramètres de compilation > Paramètres du lecteur > Autres paramètres).

5. Dans la zone Target API level (Niveau d'API cible), sélectionnez une version.

6. Dans la zone Scripting backend (Backend de script), saisissez IL2CPP.

7. Dans la zone Target architectures (Architectures cibles), sélectionnez une valeur.

8. Notez le nom du package package_name. Vous pourrez utiliser ces informations ultérieurement.

   

9. Copier les ressources Android depuis la Play Console

10. Ajouter les ressources Android à votre projet Unity

Chemins de migration

Le chemin de migration approprié pour votre jeu dépend de la façon dont il implémente les services de jeux Play v1 et gère l'identité des joueurs. Pour assurer une transition fluide et éviter la perte de données de joueurs, identifiez le scénario qui correspond le mieux à votre configuration existante et suivez les étapes correspondantes.

Option 1 : Pour les jeux où l'IGA est lié à l'ID de joueur des services de jeux Play

Ce scénario s'applique aux jeux qui ont utilisé Player ID des services de jeux Play comme seul identifiant pour le compte de jeu d'un joueur et qui n'ont pas précédemment demandé ni stocké d'OpenID. Le principal défi consiste à associer l'IGA existant à un identifiant principal (OpenID) sans perdre le lien avec la progression du joueur.

Le flux de migration comprend les étapes suivantes :

1. Lorsque le jeu est lancé, le SDK des services de jeux Play v2 authentifie automatiquement et silencieusement la plate-forme.

2. L'écran de connexion du jeu s'affiche. Cet écran doit comporter un bouton Se connecter avec Google (SiWG, Sign-in with Google) à la place du bouton Google Play. Pour intégrer :

   1. Téléchargez CredManBridge.java dans votre dossier. Cette classe Java sert de pont entre Unity et la bibliothèque 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 : CONNEXION INTERACTIVE (appelée lors d'un clic sur un bouton) ---
      // Force l'affichage de la feuille de sélection de compte ou d'ajout de compte.
      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. Intégration de Credential Manager :

      • Utilisez GetGoogleIdOption avec setFilterByAuthorizedAccounts(true) pour les connexions silencieuses afin de ne connecter que les utilisateurs ayant déjà autorisé l'application.
      • Utilisez setFilterByAuthorizedAccounts(false) pour les connexions interactives afin de permettre aux utilisateurs de sélectionner un compte ou d'en ajouter un.

   3. Demande de champ d'application :

      • Après avoir obtenu les identifiants Google de base, il crée un AuthorizationRequest demandant le champ d'application spécifique hérité : https://www.googleapis.com/auth/games_lite.
      • Ce champ d'application est essentiel, car il accorde au serveur l'autorisation de rechercher l'ancien PlayerID de l'utilisateur.

   4. Gestion des résultats :

      • Si l'utilisateur accorde l'autorisation (ou l'a déjà accordée), le pont renvoie ServerAuthCode à Unity.
      • Si l'utilisateur n'a pas accordé l'autorisation (scénario "Nouvel utilisateur"), l'API renvoie un PendingIntent. Dans cet exemple, l'intent est supprimé et l'utilisateur est traité comme un nouvel utilisateur pour simplifier le flux.

3. Pour prendre en charge les services Credential Manager et Google Identity, assurez-vous que les dépendances suivantes sont ajoutées à votre configuration Gradle mainTemplate.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'
   }

   • Credential Manager : gère l'orchestration de l'identité et l'UI pour la sélection de compte.
   • Bibliothèque GoogleID : fournit spécifiquement GetGoogleIdOption pour récupérer les jetons OpenID Connect.
   • Authentification des services Play : requise pour maintenir la compatibilité et demander le champ d'application GAMES_LITE pour la récupération de l'ancien Player ID.

4. Lorsque le joueur appuie sur le bouton Se connecter avec Google et sélectionne un compte Google, le jeu doit récupérer deux identifiants distincts :

   • Le OpenID, identifiant principal pour l'association de l'IGA.
   • Le Player ID des services de jeux Play, récupéré à l'aide du champ d'application GAMES_LITE, pour rechercher l'IGA du joueur dans votre système de backend et effectuer l'association.

5. Lors des lancements de jeux ultérieurs, les joueurs peuvent accéder à leur IGA via le flux SiWG, sans que les jeux aient besoin d'utiliser Player ID comme identifiant principal.

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