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

Se connecter dans les jeux Android

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 des appels aux API Google Play Games Services. Cette documentation explique comment mettre en œuvre une expérience de connexion fluide dans votre jeu.

Implémenter la connexion des joueurs

La classe GoogleSignInClient est le point d'entrée principal pour récupérer le compte du joueur actuellement connecté et pour le connecter 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 la 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 champs d'application ni données de profil Google, sauf s'ils sont essentiels à votre cas d'utilisation. Toute autre portée entraîne l'échec de la première connexion silencieuse, sauf pour les 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 aux étapes précédentes. Si l'appel aboutit, l'API Google Sign-In renvoie une instance de GoogleSignInClient.

Vérifier si l'utilisateur 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 vraies (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>. Lorsque la tâche est 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 en tant que résultat, ou sur null, ce qui indique qu'aucun utilisateur n'est connecté.

Si la tentative de connexion silencieuse échoue, vous pouvez envoyer l'intent de connexion pour afficher une interface utilisateur de connexion, comme décrit dans la section 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 effectuer la connexion de manière silencieuse, procédez comme suit:

Appelez la méthode silentSignIn() sur GoogleSignInClient pour démarrer le flux de connexion silencieux. Cet appel renvoie un objet Task<GoogleSignInAccount> contenant un GoogleSignInAccount si la connexion silencieuse aboutit.
Gérez la réussite ou l'échec de la connexion du joueur en remplaçant OnCompleteListener.
- Si la tâche de connexion a abouti, obtenez l'objet GoogleSignInAccount en appelant getResult().
- Si la connexion a échoué, vous pouvez envoyer un intent de connexion pour lancer un flux de connexion interactif. Pour obtenir la liste des écouteurs de rappel supplémentaires 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é. Le 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 vous connecter avec une interaction du joueur, votre application doit lancer l'intent de connexion. Si l'opération aboutit, 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 pour le compte de votre application. Le résultat est renvoyé via le rappel onActivityResult.

Pour effectuer la connexion 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'intent renvoyé.

Si la connexion a réussi, récupérez l'objet GoogleSignInAccount à partir de GoogleSignInResult.
Si la connexion échoue, 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 lecteur. Si votre jeu utilise des informations sur le joueur, telles que 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 comme paramètre.
Utilisez les méthodes PlayersClient pour charger de manière asynchrone l'objet Player contenant 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 le 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 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:

inclure un com.google.android.gms.common.SignInButton sur la mise en page de l'activité principale ; ou
Concevez un bouton de connexion personnalisé conformément aux 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 la section Effectuer une connexion interactive.

Cet extrait de code montre comment ajouter un bouton de connexion dans la méthode onCreate() pour 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 des fenêtres pop-up 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 "Bienvenue" ou "Succès débloqués". 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

La déconnexion s'effectue en appelant 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.
        }
      });
}