Cette page a été traduite par l'API Cloud Translation.

Se connecter dans les jeux Android

Suite à l'arrêt de l'API Google Sign-In, nous allons supprimer le SDK v1 pour les jeux en 2026. Après février 2025, vous ne pourrez plus publier de titres qui viennent d'être intégrés au SDK v1 de Jeux sur Google Play. Nous vous recommandons d'utiliser plutôt le SDK v2 de Jeux.
Bien que les titres existants avec les intégrations de jeux v1 précédentes continuent de fonctionner pendant quelques années, nous vous encourageons à migrer vers la v2 à partir de juin 2025.
Ce guide explique comment utiliser la version 1 du SDK des services de jeux Play. Pour en savoir plus sur la dernière version du SDK, consultez la documentation de la version 2.

Pour pouvoir accéder aux fonctionnalités des services de jeux Google Play, votre jeu doit fournir le compte du joueur connecté. Si le joueur n'est pas authentifié, votre jeu peut rencontrer des erreurs lors de l'appel des API Google Play Jeux. Cette documentation explique comment mettre en œuvre une expérience de connexion fluide dans votre jeu.

Implémenter la connexion du joueur

La classe GoogleSignInClient est le point d'entrée principal pour récupérer le compte du joueur actuellement connecté et pour connecter le joueur s'il ne l'a pas déjà fait sur votre application sur l'appareil.

Pour créer un client de connexion, procédez comme suit :

Créez un client de connexion via l'objet GoogleSignInOptions, comme indiqué dans l'extrait de code suivant. Dans GoogleSignInOptions.Builder, pour configurer votre connexion, vous devez spécifier GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Si vous souhaitez utiliser un SnapshotsClient, ajoutez .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) à votre GoogleSignInOptions.Builder, comme indiqué dans l'extrait de code suivant :
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Attention : Ne demandez pas d'autres autorisations ni données de profil Google, sauf si elles sont essentielles pour votre cas d'utilisation. Tout autre champ d'application entraîne l'échec de la première connexion silencieuse, à l'exception des utilisateurs qui se sont déjà connectés avec succès sur un autre appareil.
Appelez la méthode GoogleSignIn.getClient() et transmettez les options que vous avez configurées lors des étapes précédentes. Si l'appel aboutit, l'API Google Sign-In renvoie une instance de GoogleSignInClient.

Vérifier si le joueur est déjà connecté

Vous pouvez vérifier si un compte est déjà connecté sur l'appareil actuel à l'aide de GoogleSignIn.getLastSignedInAccount() et si ce compte dispose déjà des autorisations requises à l'aide de GoogleSignIn.hasPermissions(). Si les deux conditions sont remplies (c'est-à-dire que getLastSignedInAccount() renvoie une valeur non nulle et que hasPermissions() renvoie true), vous pouvez utiliser le compte renvoyé par getLastSignedInAccount() en toute sécurité, même si l'appareil est hors connexion.

Vous pouvez appeler silentSignIn() pour récupérer le compte du joueur actuellement connecté et essayer de connecter les joueurs sans afficher d'interface utilisateur s'ils se sont déjà connectés à votre application sur un autre appareil.

La méthode silentSignIn() renvoie un Task<GoogleSignInAccount>. Une fois la tâche terminée, vous définissez le champ GoogleSignInAccount que vous avez déclaré précédemment sur le compte de connexion que la tâche renvoie comme résultat, ou sur null, indiquant qu'aucun utilisateur n'est connecté.

Si la tentative de connexion silencieuse échoue, vous pouvez éventuellement envoyer l'intention de connexion pour afficher une interface utilisateur de connexion, comme décrit dans Effectuer une connexion interactive.

Étant donné que l'état du joueur connecté peut changer lorsque l'activité n'est pas au premier plan, nous vous recommandons d'appeler silentSignIn() à partir de la méthode onResume() de l'activité.

Pour vous connecter en mode silencieux, procédez comme suit :

Appelez la méthode silentSignIn() sur GoogleSignInClient pour démarrer le flux de connexion silencieuse. Cet appel renvoie un objet Task<GoogleSignInAccount> qui contient un GoogleSignInAccount si la connexion silencieuse réussit.
Gérez la réussite ou l'échec de la connexion du joueur en remplaçant OnCompleteListener.
- Si la tâche de connexion a réussi, obtenez l'objet GoogleSignInAccount en appelant getResult().
- Si la connexion n'a pas réussi, vous pouvez envoyer une intention de connexion pour lancer un flux de connexion interactif. Pour obtenir la liste des autres écouteurs de rappel que vous pouvez utiliser, consultez le guide du développeur de l'API Tasks et la documentation de référence de l'API Task.

L'extrait de code suivant montre comment votre application peut effectuer une connexion silencieuse :

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

Si la tentative de connexion silencieuse échoue, vous pouvez appeler getException() pour obtenir un ApiException avec le code d'état détaillé. Un code d'état CommonStatusCodes.SIGN_IN_REQUIRED indique que le joueur doit effectuer une action explicite pour se connecter. Dans ce cas, votre application doit lancer un flux de connexion interactif, comme décrit dans la section suivante.

Pour se connecter avec l'interaction du joueur, votre application doit lancer l'intention de connexion. Si l'opération réussit, l'API Google Sign-In affiche une interface utilisateur qui invite le joueur à saisir ses identifiants pour se connecter. Cette approche simplifie le développement de votre application, car l'activité de connexion gère des scénarios tels que la nécessité de mettre à jour les services Google Play ou d'afficher des invites de consentement, au nom de votre application. Le résultat est renvoyé via le rappel onActivityResult.

Pour vous connecter de manière interactive, procédez comme suit :

Appelez getSigninIntent() sur GoogleSignInClient pour obtenir un intent de connexion, puis appelez startActivity() et transmettez cet intent. L'extrait de code suivant montre comment votre application peut lancer un flux de connexion interactif :

private void startSignInIntent() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}

Dans le rappel onActivityResult(), gérez le résultat de l'intention renvoyée.

Si la connexion a réussi, récupérez l'objet GoogleSignInAccount à partir de GoogleSignInResult.
Si la connexion a échoué, vous devez gérer l'erreur de connexion (par exemple, en affichant un message d'erreur dans une alerte). L'extrait de code suivant montre comment votre application peut gérer les résultats de la connexion du joueur :

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

Récupérer les informations sur le joueur

Le GoogleSignInAccount renvoyé par l'API Google Sign-In ne contient aucune information sur le joueur. Si votre jeu utilise des informations sur le joueur, comme son nom à afficher et son ID, vous pouvez suivre ces étapes pour les récupérer.

Obtenez un objet PlayersClient en appelant la méthode getPlayersClient() et en transmettant GoogleSignInAccount en tant que paramètre.
Utilisez les méthodes PlayersClient pour charger de manière asynchrone l'objet Player qui contient les informations d'un joueur. Par exemple, vous pouvez appeler getCurrentPlayer() pour charger le joueur actuellement connecté. Si la tâche renvoie un ApiException avec un code d'état SIGN_IN_REQUIRED, cela signifie que le lecteur doit être réauthentifié. Pour ce faire, appelez GoogleSignInClient.getSignInIntent() pour connecter le lecteur de manière interactive.
Si la tâche renvoie correctement l'objet Player, vous pouvez ensuite appeler les méthodes de l'objet Player pour récupérer des informations spécifiques sur le joueur (par exemple, getDisplayName() ou getPlayerId()).

Pour fournir un bouton de connexion Google standard dans votre jeu, vous pouvez utiliser l'une des approches suivantes :

Incluez un com.google.android.gms.common.SignInButton dans la mise en page de l'activité principale.
Concevez un bouton de connexion personnalisé en suivant les consignes de branding pour Google Sign-In.

Lorsque les utilisateurs cliquent sur le bouton de connexion, votre jeu doit lancer le flux de connexion en envoyant un intent de connexion, comme décrit dans Effectuer une connexion interactive.

Cet extrait de code montre comment ajouter un bouton de connexion dans la méthode onCreate() de votre activité.

@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);
}

L'extrait de code suivant montre comment envoyer l'intent de connexion lorsque l'utilisateur clique sur le bouton de connexion.

@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);
  }
}

Afficher les pop-ups de jeu

Vous pouvez afficher des vues pop-up dans votre jeu à l'aide de la classe GamesClient. Par exemple, votre jeu peut afficher un pop-up "Bon retour" ou "Succès débloqué". Pour autoriser les services de jeux Google Play à lancer des pop-ups dans les vues de votre jeu, appelez la méthode setViewForPopups(). Vous pouvez personnaliser davantage l'emplacement du pop-up à l'écran en appelant setGravityForPopups().

Déconnecter le joueur

Pour se déconnecter, appelez la méthode signOut() sur GoogleSignInClient.

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.
        }
      });
}

Se connecter dans les jeux Android Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Implémenter la connexion du joueur

Vérifier si le joueur est déjà connecté

Effectuer une connexion silencieuse

Effectuer une connexion interactive

Récupérer les informations sur le joueur

Prévoyez un bouton de connexion.

Afficher les pop-ups de jeu

Déconnecter le joueur

Se connecter dans les jeux Android