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. DansGoogleSignInOptions.Builder
, pour configurer votre connexion, vous devez spécifierGoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
.GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
Si vous souhaitez utiliser un
SnapshotsClient
, ajoutez.requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
à votreGoogleSignInOptions.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();
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 deGoogleSignInClient
.
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.
Effectuer une 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 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()
surGoogleSignInClient
pour démarrer le flux de connexion silencieux. Cet appel renvoie un objetTask<GoogleSignInAccount>
contenant unGoogleSignInAccount
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 réussi, récupérez l'objet
GoogleSignInAccount
en appelantgetResult()
. - 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
.
- Si la tâche de connexion a réussi, récupérez l'objet
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.
Effectuer une connexion interactive
Pour que le joueur puisse se connecter, 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 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()
surGoogleSignInClient
pour obtenir un intent de connexion, puis appelezstartActivity()
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 deGoogleSignInResult
. - 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(); } } }
- Si la connexion a réussi, récupérez l'objet
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éthodegetPlayersClient()
et en transmettantGoogleSignInAccount
comme paramètre. - Utilisez les méthodes
PlayersClient
pour charger de manière asynchrone l'objetPlayer
contenant les informations d'un joueur. Par exemple, vous pouvez appelergetCurrentPlayer()
pour charger le joueur actuellement connecté. Si la tâche renvoie unApiException
avec le code d'étatSIGN_IN_REQUIRED
, cela signifie que le lecteur doit être réauthentifié. Pour ce faire, appelezGoogleSignInClient.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'objetPlayer
pour récupérer des informations spécifiques sur le joueur (par exemple,getDisplayName()
ougetPlayerId()
).
Fournir un bouton de connexion
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é 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 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 "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. } }); }