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 le compte du joueur connecté. Si le joueur n'est pas authentifié, votre jeu peut rencontrer des erreurs 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 des joueurs

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

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

Créez un client de connexion via la 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, puis 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 à moins ils sont essentiels pour votre cas d'utilisation. Pour tout autre champ d'application, la connexion silencieuse échouera, sauf pour les utilisateurs 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 est l'opération réussie, 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 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 en toute sécurité le compte renvoyé par 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 ont s'est bien connecté à 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 s'affiche comme résultat, ou à 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 l'interface utilisateur de connexion, comme décrit dans Connexion interactive.

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

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

Appelez la méthode silentSignIn() sur GoogleSignInClient pour lancer le flux 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 remplaçant OnCompleteListener
- Si la tâche de connexion a abouti, obtenez le 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 la Guide du développeur pour l'API Tasks et Task Documentation de référence de l'API.

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() jusqu'à obtenir un ApiException avec le code d'état détaillé. Un code d'état de 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 vous connecter avec une interaction du joueur, votre application 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 vous connecter. Cette approche simplifie le développement de votre application, car l'activité de connexion gère dans certains cas, par exemple avoir besoin de mettre à jour les services Google Play ou d'afficher des invites de consentement, sur le au nom de l'utilisateur. Le résultat est renvoyé via la onActivityResult .

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

Appelez getSigninIntent() sur le GoogleSignInClient pour obtenir un intent de connexion, puis appelez startActivity() et transmettre cet intent. L'extrait de code suivant montre comment votre application 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 la onActivityResult() pour gérer le résultat de l'intent renvoyé.

Si la connexion aboutit, récupérez le Objet GoogleSignInAccount de GoogleSignInResult.
Si la connexion échoue, vous devez traiter l'erreur de connexion (par exemple, en l'affichage d'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 d'un 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 des informations sur le joueur

Le GoogleSignInAccount renvoyé par l'API Google Sign-In ne contient aucun joueur des informations. Si votre jeu utilise des informations sur le joueur, telles que 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 comme paramètre.
Utilisez les méthodes PlayersClient pour charger le Player de manière asynchrone. contenant les informations d'un joueur. Par exemple, vous pouvez appeler getCurrentPlayer(). pour charger le lecteur actuellement connecté. Si la tâche renvoie une ApiException avec le code d'état sur SIGN_IN_REQUIRED, cela indique que le joueur doit être à nouveau authentifié. Pour ce faire, appelez GoogleSignInClient.getSignInIntent() pour se connecter au lecteur de manière interactive.
Si la tâche renvoie correctement l'objet Player, vous pouvez appeler les méthodes de la Un objet Player pour récupérer des informations spécifiques 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 utiliser l'une des ces approches:

Inclure un com.google.android.gms.common.SignInButton sur la mise en page de l'activité principale ; ou
Concevoir un bouton de connexion personnalisé conformément au branding de Google Sign-In consignes.

Lorsque les utilisateurs cliquent sur le bouton de connexion, votre jeu doit lancer le flux de connexion en envoyant un l'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 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 vous 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 de 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 "Bienvenue" ou "Réussites déverrouillées". Pour autoriser les services de jeux Google Play pour 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 lecteur

La déconnexion s'effectue via un appel de la méthode signOut() au niveau de 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.
        }
      });
}