Attivazione dell'accesso lato server ai servizi per i giochi di Google Play

Se il tuo gioco utilizza un server di backend, ti consigliamo di utilizzare Accedi con Google per autenticare i giocatori e trasferire in modo sicuro l'identità del giocatore al server di backend. In questo modo, il gioco può recuperare in modo sicuro l'identità e altri dati del giocatore senza essere esposti a potenziali manomissioni mentre attraversa il dispositivo.

In questo scenario, il gioco chiede al giocatore di accedere ai servizi per i giochi di Google Play come di consueto. Quando il player esegue l'accesso, l'oggetto GoogleSignInAccount contiene uno speciale codice monouso (chiamato codice di autenticazione del server) che il client trasmette al server. Quindi, 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 Games Services.

Per ulteriori indicazioni su come aggiungere l'accesso ai giochi, consulta la pagina Accedere ad Android Giochi.

Per visualizzare un esempio di codice dettagliato che mostra come utilizzare Accedi con Google per autenticare i giocatori, consulta l'esempio di clientserverskeleton su GitHub.

Per accedere 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: come parte dell'accesso, richiedi un codice di autenticazione del server per le credenziali del tuo server e trasmettilo al tuo 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 usa questo comando per chiamare le API REST dei servizi per i giochi di Play.

Prima di iniziare

Per poter integrare Accedi con Google nel gioco, devi prima aggiungere il gioco in Google Play Console, come descritto nella sezione Configurare i 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 supporto back-end per i giochi web. Tuttavia, fornisce supporto per il server di backend per il server del tuo gioco Android.

Se vuoi utilizzare le API REST per i servizi per i giochi di Google Play nella tua app lato server, procedi nel seguente modo:

  1. Crea un'app web associata per il tuo gioco nella sezione App collegate di Google Play Console. Tieni presente che launch_url non viene utilizzato per questo flusso e può essere lasciato vuoto.
  2. Per recuperare le informazioni sulle credenziali della tua app, segui questi passaggi:
    1. Dal tuo gioco in Google Play Console, fai clic su Dettagli del gioco.
    2. Scorri verso il basso fino alla sezione Progetto console API e fai clic sul link al progetto della console API.
    3. Dalla schermata API e servizi > Credenziali nella console API di Google, scarica il file client_secret.json per l'app web e salvalo in una posizione a cui il tuo server può accedere. Registra l'ID client della credenziale per utilizzarlo in seguito.
  3. Riavvia l'app lato server in modo che sia pronta per accettare le richieste dall'app client del tuo gioco.

Esecuzione dell'accesso sul client

La classe GoogleSignInClient è il punto di accesso principale per recuperare l'account del player a cui è stato eseguito l'accesso e per accedere al player se non l'hanno ancora fatto nella tua app sul dispositivo.

Per creare un client di accesso, procedi nel seguente modo:

  1. Creare un client di accesso tramite l'oggetto GoogleSignInOptions. In GoogleSignInOptions.Builder per configurare l'accesso, devi specificare GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
  2. Devi inoltre specificare che il tuo gioco richiede un codice di autenticazione per il server di backend chiamando il metodo GoogleSignInOptions.Builder.requestServerAuthCode() con l'ID client del server come parametro. Recuperarai il codice di autenticazione in un secondo momento per i token di accesso sul server di backend, come descritto nella sezione Ottenere il codice di autenticazione del server.
  3. Chiama il metodo GoogleSignIn.getClient() e inserisci le opzioni configurate in precedenza. Se la chiamata riesce, l'API Accedi con Google restituisce un'istanza di GoogleSignInClient.
  4. Dopo aver ottenuto l'istanza GoogleSignInClient, devi procedere con l'accesso del lettore in modalità silenziosa dal dispositivo onResume() dell'attività, come descritto nella sezione Eseguire l'accesso silenzioso.

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 autenticazione del server

Per recuperare un codice di autenticazione server che il gioco può utilizzare per i token di accesso sul server di backend, richiama il metodo getServerAuthCode() nell'oggetto GoogleSignInAccount restituito da Accedi con Google dopo l'accesso al player riuscito.

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 autenticazione server con un token di accesso sul server.

Invia il codice di autenticazione server al tuo server di backend per lo scambio e all'aggiornamento dei token. Usare il token di accesso per chiamare l'API Google Play Games Services per conto del player e, facoltativamente, archiviarlo per acquisire un nuovo token di accesso alla scadenza del token.

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. Viene utilizzata l'app clientserverskeleton di esempio:

/**
 * 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 saperne 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 Abilitazione dell'accesso lato server.

Gestire l'uscita del giocatore

Per disconnettere i giocatori dal tuo gioco, chiama il metodo signOut() su GoogleSignInClient. Per uno snippet di codice di esempio, consulta la sezione Uscire il player.

Chiama le API REST dal server

Fai riferimento alle API REST per i servizi per i giochi di Google Play per una descrizione completa delle chiamate API disponibili.

Esempi di chiamate API REST che potresti trovare utili:

Giocatore

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

Amici

Assicurati di consultare la guida Amici, che spiega in dettaglio gli amici.

Obiettivi

Assicurati di leggere la guida Obiettivi, che spiega più dettagliatamente gli obiettivi.

  • Vuoi ricevere un elenco degli obiettivi attuali? Puoi effettuare una chiamata a AchievementDefinizioni.list.
  • Combinalo con una chiamata alla pagina Achievements.list per scoprire quali sono state sbloccate dal player.
  • Il giocatore ha raggiunto un obiettivo? Usa Achievement.unlock per sbloccarla!
  • Il giocatore ha fatto progressi verso un obiettivo parziale? Usa Achievements.increment per segnalare i progressi (e scoprire se il player lo 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 reimpostare lo stato originale degli obiettivi.

Classifiche

Consulta la guida Classifica, che spiega le classifiche in modo più dettagliato.

  • Vuoi visualizzare un elenco di tutti i tabelloni nel gioco? Chiama Classificas.list.
  • Il giocatore ha finito il gioco? Puoi inviare il suo punteggio a Scores.submit e scoprire se si tratta di un nuovo miglior punteggio.
  • Vuoi visualizzare una classifica? Recupera i dati da Scores.list e mostrali all'utente.
  • Utilizza Scores.listWindow per trovare un assortimento di punteggi vicini al punteggio più alto dell'utente.
  • Per ulteriori informazioni sul punteggio del giocatore in una determinata classifica (ad esempio, se il giocatore è nel 12% di tutti i giocatori), chiama punteggi.get.
  • Stai eseguendo il debug di un gioco? Prova a chiamare Scores.reset dalle API di gestione per reimpostare tutti i punteggi di quel giocatore da una determinata classifica