Accesso lato server ai servizi per i giochi di Google Play

Ti consigliamo di autenticare i giocatori e di trasmettere in modo sicuro la loro identità al server di backend. In questo modo, il tuo gioco può recuperare in modo sicuro l'identità del giocatore e altri dati senza essere esposto a potenziali manomissioni durante il passaggio attraverso il dispositivo.

In questo scenario, dopo che il giocatore ha eseguito l'accesso, puoi richiedere un codice speciale monouso (chiamato codice di autenticazione del server) dall'SDK Play Games Services v2, che il client passa al server. Poi, sul server, scambia il codice di autenticazione del server con un token OAuth 2.0 che il server può utilizzare per effettuare chiamate all'API Google Play Services per i giochi.

Per ulteriori indicazioni su come aggiungere l'accesso nei tuoi giochi, consulta Accedere ai giochi per Android.

Per l'accesso offline sono necessari i seguenti passaggi:

  1. In Google Play Console: crea una credenziale per il tuo server di gioco. Il tipo di client OAuth della credenziale sarà "web".
  2. Nell'app per Android: durante l'accesso, richiedi un codice di autenticazione del server per la credenziale del tuo server e trasmettilo al server.
  3. Sul server di gioco: scambia il codice di autenticazione del server con un token di accesso OAuth utilizzando i servizi di autenticazione di Google, quindi utilizzalo per chiamare le API REST di Play Games Services.

Prima di iniziare

Per prima cosa, devi aggiungere il tuo gioco in Google Play Console, come descritto in Configurare i servizi per i giochi di Google Play, e integrare Accedi con i servizi per i giochi di Google Play con il tuo gioco.

Creare un'app web lato server

I Servizi per i giochi di Google Play non forniscono il supporto di backend per i giochi web. Tuttavia, fornisce il supporto del server di backend per il server del tuo gioco per Android.

Se vuoi utilizzare le API REST per i servizi Google Play Giochi nella tua app lato server, segui questi passaggi:

  1. In Google Play Console, seleziona un gioco.
  2. Vai a Servizi per i giochi di Play > Configurazione e gestione > Configurazione.
  3. Seleziona Aggiungi credenziale per aprire la pagina Aggiungi credenziale. Seleziona Server di giochi come tipo di credenziale e vai alla sezione Autorizzazione.
    1. Se il tuo server di giochi ha già un ID client OAuth, selezionalo dal menu a discesa. Dopo aver salvato le modifiche, vai alla sezione successiva.
    2. Se non hai già un ID client OAuth per il tuo server di giochi, puoi crearne uno.
      1. Fai clic su Crea client OAuth e segui il link Crea ID client OAuth.
      2. Verrà visualizzata la pagina Crea ID client OAuth della piattaforma Google Cloud per il progetto associato al tuo gioco.
      3. Compila il modulo della pagina e fai clic su Crea. Assicurati di impostare il tipo di applicazione su Applicazione web.
      4. Torna alla sezione Autorizzazione della pagina Aggiungi credenziale, seleziona il client OAuth appena creato e salva le modifiche.

Ricevi 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:

  1. Chiama requestServerSideAccess dal client.

    1. Assicurati di utilizzare l'ID client OAuth registrato per il tuo server di gioco e non l'ID client OAuth della tua applicazione per Android.
    2. (Facoltativo) Se il server di gioco richiede l'accesso offline (accesso a lungo termine tramite un token di aggiornamento) ai servizi per i giochi di Play, puoi impostare il parametro forceRefreshToken su true.
    GamesSignInClient gamesSignInClient = PlayGames.getGamesSignInClient(this);
gamesSignInClient
  .requestServerSideAccess(OAUTH_2_WEB_CLIENT_ID, /* forceRefreshToken= */ false)
  .addOnCompleteListener( task -> {
    if (task.isSuccessful()) {
      String serverAuthToken = task.getResult();
      // Send authentication code to the backend game server to be
      // exchanged for an access token and used to verify the player
      // via the Play Games Services REST APIs.
    } else {
      // Failed to retrieve authentication code.
    }
});

  2. Invia il token del codice di autenticazione OAuth al tuo server di backend in modo che possa essere scambiato, l'ID giocatore verificato in base alle API REST di Play Games Services e poi autenticato con il tuo gioco.

Invia il codice di autorizzazione del server

Invia il codice di autenticazione del server al tuo server di backend per scambiarlo con token di accesso e di aggiornamento. Utilizza il token di accesso per chiamare l'API Play Games Services per conto del giocatore e, facoltativamente, memorizza il token di aggiornamento per acquisire un nuovo token di accesso quando quello esistente scade.

Il seguente snippet di codice mostra come implementare il codice lato server nel linguaggio di programmazione Java per scambiare il codice di autenticazione del server con i token di accesso. Utilizza l'app di esempio 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 shouldn't 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;
}

Chiama le API REST dal server

Consulta le API REST per i servizi Google Play Giochi per una descrizione completa delle chiamate API disponibili.

Di seguito sono riportati alcuni esempi di chiamate API REST che potresti trovare utili:

Giocatore

Vuoi ottenere l'ID e i dati del profilo del giocatore che ha eseguito l'accesso? Chiama Players.get con 'me' come ID.

Amici

Per maggiori dettagli, consulta la guida Amici.

Obiettivi

Per maggiori dettagli, consulta la guida ai Obiettivi.

Classifiche

Per maggiori dettagli, consulta la guida alle classifiche.

  • Vuoi ricevere un elenco di tutti i tabelloni nel gioco? Esegui una chiamata a Leaderboards.list.

  • Se un giocatore ha completato una partita, puoi inviare il suo punteggio a Scores.submit e scoprire se si tratta di un nuovo record.

  • Per visualizzare una classifica, recupera i dati da Scores.list e mostrali all'utente.

  • Utilizza Scores.listWindow per trovare una serie di punteggi vicini al punteggio più alto dell'utente.

  • Per ottenere maggiori informazioni sul punteggio del giocatore in una determinata classifica (ad esempio, se il giocatore è tra i primi 12% di tutti i giocatori), chiama Scores.get.

  • Se stai eseguendo il debug di un gioco, puoi chiamare Scores.reset dalle API di gestione per reimpostare tutti i punteggi per quel giocatore da un determinato leaderboard.