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

Se connecter dans les jeux Android

Pour que vous puissiez 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é, des erreurs peuvent se produire dans votre jeu lorsque vous appelez les API des services de jeux Google Play. Cette documentation explique comment mettre en œuvre une expérience de connexion fluide dans votre jeu.

Implémenter la connexion de joueur

La classe GoogleSignInClient est le point d'entrée principal pour récupérer le compte du joueur actuellement connecté et pour se connecter au joueur s'il ne l'a pas déjà fait sur votre application dans 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 champs d'application ni d'autres données de profil Google, à moins qu'ils ne soient essentiels à votre cas d'utilisation. Tout autre champ d'application entraîne l'échec de la première connexion silencieuse, sauf pour les utilisateurs qui se sont déjà connecté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 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 accordées à l'aide de GoogleSignIn.hasPermissions(). Si les deux conditions sont remplies, à savoir que getLastSignedInAccount() renvoie une valeur non nulle et que hasPermissions() renvoie true, vous pouvez utiliser en toute sécurité le compte renvoyé depuis getLastSignedInAccount(), même si l'appareil est hors connexion.

Connexion silencieuse

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 connectés à votre application sur un autre appareil.

La méthode silentSignIn() renvoie un Task<GoogleSignInAccount>. Une fois l'exécution de 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'il n'y a pas d'utilisateur connecté.

Si la tentative de connexion silencieuse échoue, vous pouvez éventuellement 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 lecteur 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 silencieuse, procédez comme suit:

Appelez la méthode silentSignIn() sur GoogleSignInClient pour démarrer la procédure de connexion silencieuse. Cet appel renvoie un objet Task<GoogleSignInAccount> qui contient un GoogleSignInAccount si la connexion silencieuse a réussi.
Gérez la réussite ou l'échec de la connexion du joueur en ignorant OnCompleteListener.
- Si la tâche de connexion a abouti, obtenez l'objet GoogleSignInAccount en appelant getResult().
- Si la connexion échoue, 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 de développement 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 établir 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.

Connexion interactive

Pour se connecter via une interaction avec le joueur, votre appli doit lancer l'intent 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 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 aboutit, récupérez l'objet GoogleSignInAccount à partir de GoogleSignInResult.
Si la connexion n'aboutit pas, 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 de 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ération des informations du 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 récupérer ces informations.

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 contenant les informations d'un joueur. Par exemple, vous pouvez appeler getCurrentPlayer() pour charger le lecteur actuellement connecté. Si la tâche renvoie un objet ApiException avec le code d'état SIGN_IN_REQUIRED, cela signifie que le lecteur doit être de nouveau authentifié. Pour ce faire, appelez GoogleSignInClient.getSignInIntent() pour vous connecter 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 détaillées sur le joueur (par exemple, getDisplayName() ou getPlayerId()).

Fournir un bouton de connexion

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

inclure un élément com.google.android.gms.common.SignInButton dans la mise en page principale de l'activité ;
Concevez un bouton de connexion personnalisé en respectant les consignes relatives à la marque de Google Sign-In.

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

Cet extrait de code vous montre comment ajouter un bouton de connexion à 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);
  }
}

Affichage des fenêtres pop-up de jeux

Vous pouvez afficher les vues pop-up dans votre jeu à l'aide de la classe GamesClient. Par exemple, votre jeu peut afficher un pop-up "Bienvenue" ou "Réussites déverrouillées". 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 l'emplacement de la fenêtre pop-up en appelant setGravityForPopups().

Déconnecter le joueur

Pour vous déconnecter, appelez la méthode signOut() sur le 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.
        }
      });
}