Si votre jeu utilise un serveur backend, nous vous recommandons d'utiliser Google Sign-In pour authentifier les joueurs et transmettre de manière sécurisée l'identité du joueur au serveur backend. Cela permet également votre jeu pour récupérer en toute sécurité l'identité du joueur et d'autres données en cas de tentative d'altération potentielle lors de son passage à travers l'appareil.
Dans ce scénario, votre jeu invite le joueur à se connecter aux services de jeux Google Play comme d'habitude. Lorsque
Le joueur se connecte correctement, l'objet GoogleSignInAccount contient un code à usage unique spécial
(appelé code d'autorisation du serveur) que le client transmet au serveur. Ensuite, sur le serveur, échangez
le code d'autorisation du serveur associé à un jeton OAuth 2.0 que le serveur peut utiliser pour appeler la
API Google Play Games Services.
Pour obtenir des conseils supplémentaires sur l'ajout de la connexion dans vos jeux, consultez Connectez-vous aux jeux Android.
Pour voir un exemple de code détaillé montrant comment utiliser Google Sign-In pour authentifier les joueurs, consultez la
Exemple clientserverskeleton sur GitHub.
Pour utiliser l'accès hors connexion, procédez comme suit :
- Dans la Google Play Console, créez des identifiants pour votre serveur de jeu. La Le type de client OAuth pour les identifiants sera "web".
- Dans l'application Android : lors de la procédure de connexion, demandez un code d'autorisation pour les identifiants de votre serveur et transmettez-les lui.
- Sur votre serveur de jeu: échangez le code d'autorisation du serveur contre un accès OAuth à l'aide des services d'authentification Google, puis utilisez-le pour appeler API REST des services de jeux Play
Avant de commencer
Pour intégrer Google Sign-In à votre jeu, vous devez d'abord l'ajouter dans le Google Play Console, comme décrit dans Configurer les services de jeux Google Play
Créer une application Web côté serveur associée à votre jeu
Les services de jeux Google Play ne proposent pas de backend pour les jeux Web. Toutefois, un serveur backend est disponible pour le serveur de votre jeu Android.
Si vous souhaitez utiliser les API REST pour les services de jeux Google Play dans votre application côté serveur, procédez comme suit :
- Créez une application Web associée à votre jeu dans la section Applications associées de
la Google Play Console. Notez que
launch_urln'est pas utilisé pour ce flux et peut être laissé vide. - Pour obtenir les identifiants de votre application, procédez comme suit:
- Dans votre jeu dans la Google Play Console, cliquez sur Informations sur le jeu.
- Faites défiler la page jusqu'à la section API Console Project (Projet de la console API), puis cliquez sur le lien. au projet de la console d'API.
- Dans la section API et Services > Écran Credentials (Identifiants) dans l'API Google
Console, téléchargez le fichier
client_secret.jsonpour votre application Web et l'enregistrer dans un emplacement auquel votre serveur peut accéder. Enregistrer le client Identifiant du jeu d'identification pour référence ultérieure.
- Redémarrez votre application côté serveur pour qu'elle soit prête à accepter les requêtes de votre l'application cliente du jeu.
Se connecter au client
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 l'objet
GoogleSignInOptions. DansGoogleSignInOptions.Builderpour configurer votre connexion, vous devez spécifierGoogleSignInOptions.DEFAULT_GAMES_SIGN_IN - Vous devez également spécifier que votre jeu nécessite une authentification
du serveur backend en appelant la méthode
GoogleSignInOptions.Builder.requestServerAuthCode()avec l'ID client du serveur comme . Vous récupérerez ultérieurement le code d'autorisation pour les jetons d'accès sur votre serveur backend, comme décrit dans la section Obtenir le code d'autorisation du serveur. - Appelez la méthode
GoogleSignIn.getClient()et transmettez les options que vous avez configurées précédemment. Si l'appel si l'opération réussit, l'API Google Sign-In renvoie une instance deGoogleSignInClient. - Une fois que vous avez obtenu l'instance
GoogleSignInClient, vous devez connecter le joueur. silencieusement à partir duonResume()de l'activité, comme décrit dans Connexion silencieuse.
Exemple :
private static final int RC_SIGN_IN = 9001;
private GoogleSignInClient mGoogleSignInClient;
private void startSignInForAuthCode() {
// Client ID for your backend server.
String webClientId = getString(R.string.webclient_id);
GoogleSignInOptions signInOption = new
GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
.requestServerAuthCode(webClientId)
.build();
GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOption);
Intent intent = signInClient.getSignInIntent();
startActivityForResult(intent, RC_SIGN_IN);
}
Obtenir le code d'autorisation du serveur
Pour récupérer un code d'autorisation de serveur que votre jeu peut utiliser pour les jetons d'accès sur votre serveur backend,
appeler getServerAuthCode()
sur la GoogleSignInAccount
objet que Google Sign-In renvoie lorsque le joueur se connecte.
Exemple :
// Auth code to send to backend server.
private String mServerAuthCode;
@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()) {
mServerAuthCode = result.getSignInAccount().getServerAuthCode();
} 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();
}
}
}
Échanger le code d'autorisation du serveur contre un jeton d'accès sur le serveur
Envoyez le code d'autorisation du serveur à votre serveur backend pour l'échanger contre des jetons d'accès et d'actualisation. Utiliser le jeton d'accès pour appeler l'API des services de jeux Google Play au nom du joueur et, éventuellement, stocker le jeton d'actualisation pour obtenir un nouveau jeton d'accès lorsqu'il expire.
L'extrait de code suivant vous montre comment implémenter le code côté serveur dans l'API de programmation pour échanger le code d’autorisation du serveur contre des jetons d’accès. Il est à l'aide du application exemple clientserverskeleton:
/**
* Exchanges the authcode for an access token credential. The credential
* is the associated with the given player.
*
* @param authCode - the non-null authcode passed from the client.
* @param player - the player object which the given authcode is
* associated with.
* @return the HTTP response code indicating the outcome of the exchange.
*/
private int exchangeAuthCode(String authCode, Player player) {
try {
// The client_secret.json file is downloaded from the Google API
// console. This is used to identify your web application. The
// contents of this file should not be shared.
//
File secretFile = new File("client_secret.json");
// If we don't have the file, we can't access any APIs, so return
// an error.
if (!secretFile.exists()) {
log("Secret file : " + secretFile
.getAbsolutePath() + " does not exist!");
return HttpServletResponse.SC_FORBIDDEN;
}
GoogleClientSecrets clientSecrets = GoogleClientSecrets.load(
JacksonFactory.getDefaultInstance(), new
FileReader(secretFile));
// Extract the application id of the game from the client id.
String applicationId = extractApplicationId(clientSecrets
.getDetails().getClientId());
GoogleTokenResponse tokenResponse =
new GoogleAuthorizationCodeTokenRequest(
HTTPTransport,
JacksonFactory.getDefaultInstance(),
"https://oauth2.googleapis.com/token",
clientSecrets.getDetails().getClientId(),
clientSecrets.getDetails().getClientSecret(),
authCode,
"")
.execute();
log("hasRefresh == " + (tokenResponse.getRefreshToken() != null));
log("Exchanging authCode: " + authCode + " for token");
Credential credential = new Credential
.Builder(BearerToken.authorizationHeaderAccessMethod())
.setJsonFactory(JacksonFactory.getDefaultInstance())
.setTransport(HTTPTransport)
.setTokenServerEncodedUrl("https://www.googleapis.com/oauth2/v4/token")
.setClientAuthentication(new HttpExecuteInterceptor() {
@Override
public void intercept(HttpRequest request)
throws IOException {
}
})
.build()
.setFromTokenResponse(tokenResponse);
player.setCredential(credential);
// Now that we have a credential, we can access the Games API.
PlayGamesAPI api = new PlayGamesAPI(player, applicationId,
HTTPTransport, JacksonFactory.getDefaultInstance());
// Call the verify method, which checks that the access token has
// access to the Games API, and that the player id used by the
// client matches the playerId associated with the accessToken.
boolean ok = api.verifyPlayer();
// Call a Games API on the server.
if (ok) {
ok = api.updatePlayerInfo();
if (ok) {
// persist the player.
savePlayer(api.getPlayer());
}
}
return ok ? HttpServletResponse.SC_OK :
HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
} catch (IOException e) {
e.printStackTrace();
}
return HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
}
Pour en savoir plus sur l'accès aux API Google depuis un serveur backend pour le compte d'un joueur connecté, consultez la section Activer l'accès côté serveur.
Gérer la déconnexion des joueurs
Pour déconnecter les joueurs de votre jeu, appelez la méthode signOut() au niveau du GoogleSignInClient. Pour une
exemple d'extrait de code, consultez
Déconnectez le lecteur.
Appeler des API REST à partir du serveur
Consultez API REST pour les services de jeux Google Play afin de découvrir une description complète des appels d'API disponibles.
Voici des exemples d'appels d'API REST qui peuvent vous être utiles :
Joueur
- Si vous souhaitez obtenir l'ID du joueur connecté et les données de son profil, Appeler Players.get
avec l'ID
'me'.
Amis
Pensez à consulter le guide des amis, qui explique en détail le fonctionnement des amis.
- Vous voulez récupérer la liste d'amis du joueur ? Appelez Players.list avec
'friends_all'en tant quecollection. - Vérifier si vous avez accès à la liste d'amis ? Appelez Players.get pour
me, puis regardez le champprofileSettings.friendsListVisibilitydans la réponse.
Réussites
Veillez à consulter le guide des réussites, qui explique les réussites plus en détail.
- Vous voulez obtenir la liste des réussites en cours ? Vous pouvez appeler la méthode AchievementDefinitions.list.
- Combinez cela avec un appel à Achievements.list pour identifier celles que le joueur a déverrouillées.
- Le joueur a-t-il obtenu une réussite ? Utilisez Achievements.unlock pour la débloquer.
- Le joueur a-t-il progressé vers une réussite partielle ? Utilisez Achievements.increment pour rendre compte de la progression (et savoir si le joueur l'a déverrouillée).
- Déboguer un jeu qui n'est pas encore en production ? Essayez d'appeler Achievements.reset ou Achievements.resetAll à partir des API de gestion pour rétablir l'état d'origine des réussites.
Classements
Veillez à consulter le guide Classements, qui explique en détail les classements.
- Si vous voulez obtenir la liste de tous les classements dans le jeu, Appelez Leaderboards.list.
- Le joueur a-t-il terminé un jeu ? Vous pouvez envoyer son score à Scores.submit pour savoir si c'est un nouveau record.
- Vous souhaitez afficher un classement ? Récupérez les données de Scores.list et présentez-les à l'utilisateur.
- Utilisez Scores.listWindow pour trouver des scores proches du record de l'utilisateur.
- Pour obtenir plus d'informations sur le score d'un joueur dans un classement particulier (par exemple, si le figure dans le top 12% des joueurs), appelez Scores.get.
- Vous déboguez un jeu ? Essayez d'appeler Scores.reset à partir du gestionnaire API permettant de réinitialiser tous les scores d'un joueur donné dans un classement particulier