Se il tuo gioco utilizza un server di backend, ti consigliamo di usare Accedi con Google per autenticare i giocatori e trasferire in modo sicuro l'identità del player al server di backend. Ciò consente inoltre il tuo gioco per recuperare in modo sicuro l'identità del giocatore e altri dati senza essere esposti a potenziali manomissioni durante il passaggio attraverso il dispositivo.
In questo scenario, il gioco chiede al giocatore di accedere ai servizi per i giochi di Google Play come di consueto. Quando
player accede correttamente, l'oggetto GoogleSignInAccount contiene uno speciale codice monouso
(denominato codice di autenticazione del server) che il client passa al server. Quindi, sul server, scambia
il codice di autorizzazione del server per un token OAuth 2.0 che il server può utilizzare per effettuare chiamate al
API Google Play Games Services.
Per ulteriori indicazioni sull'aggiunta dell'accesso nei tuoi giochi, vedi Accedi in Giochi Android.
Per un esempio di codice dettagliato che mostra come utilizzare Accedi con Google per autenticare i giocatori, consulta la
Esempio di clientserverskeleton su GitHub.
Per l'accesso offline sono necessari i seguenti passaggi:
- In Google Play Console: crea una credenziale per il tuo server di gioco. La Il tipo di client OAuth della credenziale sarà "web".
- Nell'app per Android: come parte della procedura di accesso, richiedi un codice di autenticazione del server per le credenziali del server e passarle al server.
- Sul server di gioco: sostituisci il codice di autenticazione del server con un accesso OAuth utilizzando i servizi di autenticazione di Google, e poi utilizzarlo per chiamare API REST dei servizi per i giochi di Play.
Prima di iniziare
Prima di poter integrare l'opzione Accedi con Google nel tuo gioco, dovrai aggiungere il gioco nella Google Play Console, come descritto in Configurazione dei servizi per i giochi di Google Play.
Creare un'applicazione web lato server associata per il tuo gioco
I servizi per i giochi di Google Play non forniscono back-end per i giochi web. Tuttavia, fornisce il supporto server back-end per il server del tuo gioco Android.
Se vuoi utilizzare API REST per i servizi Google Play Giochi nell'app lato server:
- Crea un'app web associata al tuo gioco nella sezione App collegate di
Google Play Console. Tieni presente che
launch_urlnon viene utilizzato per questo flusso e può essere lasciato vuoto. - Per recuperare le informazioni sulle credenziali per la tua app, segui questi passaggi:
- Dal tuo gioco in Google Play Console, fai clic su Dettagli del gioco.
- Scorri verso il basso fino alla sezione Progetto della console API e fai clic sul link. al progetto della console API.
- Dalla sezione API e Servizi > Schermata Credenziali nell'API di Google
Console, scarica il file
client_secret.jsonper l'app web e salvarlo in una posizione accessibile dal tuo server. Registra il client ID della credenziale per riferimento futuro.
- Riavvia l'app lato server in modo che sia pronta per accettare le richieste dal tuo nell'app client del gioco.
Esecuzione dell'accesso sul client
La classe GoogleSignInClient è il punto di ingresso principale per recuperare l'account della classe
lettore che ha eseguito l'accesso e per eseguire l'accesso se non l'ha fatto in precedenza nell'app nel
dispositivo.
Per creare un client di accesso:
- Crea un client di accesso tramite l'oggetto
GoogleSignInOptions. NellaGoogleSignInOptions.Builderper configurare l'accesso, devi specificareGoogleSignInOptions.DEFAULT_GAMES_SIGN_IN. - Devi anche specificare che il gioco richiede un'autenticazione
per il tuo server di backend chiamando il
GoogleSignInOptions.Builder.requestServerAuthCode()con l'ID client del server come . Recupererai il codice di autorizzazione in un secondo momento per i token di accesso sul tuo server di backend, come descritto in Recuperare il codice di autorizzazione del server. - Chiama il metodo
GoogleSignIn.getClient()e trasmetti le opzioni che hai configurato in precedenza. Se la chiamata correttamente, l'API Accedi con Google restituisce un'istanza diGoogleSignInClient. - Una volta ottenuta l'istanza di
GoogleSignInClient, devi procedere con l'accesso del player automaticamente dalonResume()dell'attività, come descritto in Accesso silenzioso.
Ecco un esempio:
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);
}
Recupera il codice di autorizzazione del server
Per recuperare un codice di autenticazione del server che il tuo gioco può utilizzare per i token di accesso sul server di backend,
chiama getServerAuthCode()
in GoogleSignInAccount
che Accedi con Google restituisce una volta eseguito l'accesso al player.
Ecco un esempio:
// 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();
}
}
}
Scambia il codice di autorizzazione del server con un token di accesso sul server
Invia il codice di autorizzazione del server al server di backend per lo scambio dei token di accesso e di aggiornamento. Usa il token di accesso per chiamare l'API dei servizi per i giochi di Google Play per conto del giocatore e, facoltativamente, Archiviare il token di aggiornamento per acquisirne uno nuovo alla scadenza.
Il seguente snippet di codice mostra come implementare il codice lato server in Java linguaggio di programmazione per scambiare il codice di autorizzazione del server con i token di accesso. È utilizzando esempio di app 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;
}
Per scoprire di più sull'accesso alle API di Google da un server di backend per conto di un player su cui è stato eseguito l'accesso, consulta l'articolo Abilitazione dell'accesso lato server.
Gestire la disconnessione del giocatore
Per disconnettere i giocatori dal gioco, chiama il metodo signOut() su GoogleSignInClient. Per un
di snippet di codice di esempio, consulta
Disconnessione del giocatore.
Chiama le API REST dal server
Consulta la pagina relativa alle API REST per i servizi Google Play Giochi per una descrizione completa delle chiamate API disponibili.
Ecco alcuni esempi di chiamate API REST che potrebbero esserti utili:
Giocatore
- Vuoi ricevere l'ID e i dati del profilo del giocatore che ha eseguito l'accesso? Chiama Players.get
con
'me'come ID.
Amici
Assicurati di leggere la guida Amici, in cui vengono spiegati più dettagliatamente gli amici.
- Vuoi recuperare l'elenco di amici del giocatore? Chiama Players.list con
'friends_all'comecollection. - Verificare di avere accesso all'elenco di amici? Chiama Players.get per
mee guarda il campoprofileSettings.friendsListVisibilitynella risposta.
Obiettivi
Assicurati di consultare la guida Obiettivi, che spiega i risultati in modo più dettagliato.
- Vuoi un elenco degli obiettivi attuali? Puoi effettuare una chiamata a AchievementDefinitions.list.
- Combina questo comportamento con una chiamata a Achievements.list per scoprire quali sono stati sbloccati dal giocatore.
- Il giocatore ha raggiunto un obiettivo? Usa Achievements.unlock per sbloccarlo.
- Il giocatore ha compiuto progressi per raggiungere un obiettivo parziale? Utilizza Achievements.increment per segnalare l'avanzamento (e scoprire se il giocatore l'ha sbloccato).
- Stai eseguendo il debug di un gioco non ancora in produzione? Prova a chiamare Achievements.reset o Achievements.resetAll dalle API di gestione per ripristinare lo stato originale degli obiettivi.
Classifiche
Assicurati di consultare la guida Classifiche, che spiega le classifiche in modo più dettagliato.
- Vuoi ottenere un elenco di tutti i tabelloni punti del gioco? Chiama il sito Leaderboards.list.
- Il giocatore ha finito di giocare? Puoi inviare il punteggio su Scores.submit e scoprire se questo è un nuovo miglior punteggio.
- Vuoi visualizzare una classifica? Ottieni i dati da Scores.list e mostrali all'utente.
- Utilizza Scores.listWindow per trovare un assortimento di punteggi simili al miglior punteggio dell'utente.
- Per avere maggiori informazioni sul punteggio di un giocatore in una determinata classifica (ad esempio, se il è tra i migliori 12% rispetto a tutti i giocatori), chiama Scores.get.
- Stai eseguendo il debug di un gioco? Prova a chiamare Scores.reset dal team di gestione API per reimpostare tutti i punteggi di quel giocatore da una determinata classifica