Serverseitigen Zugriff auf Google Play-Spieldienste aktivieren

Wir empfehlen, Spieler zu authentifizieren und die Identität des Spielers sicher an den Back-End-Server weiterzugeben. So kann Ihr Spiel die Identität und andere Daten des Spielers sicher abrufen, ohne dass sie beim Übertragen über das Gerät manipuliert werden können.

In diesem Szenario können Sie nach der erfolgreichen Anmeldung des Spielers einen speziellen Einmalcode (Serverautorisierungscode) vom Play Spiele-Dienste v2 SDK anfordern, den der Client an den Server weitergibt. Tauschen Sie dann auf dem Server den Serverautorisierungscode gegen ein OAuth 2.0-Token aus, mit dem der Server Aufrufe an die Google Play-Spieldienste API ausführen kann.

Weitere Informationen zum Hinzufügen der Anmeldung in Ihren Spielen finden Sie unter Anmeldung in Android-Spielen.

Für den Offlinezugriff sind die folgenden Schritte erforderlich:

  1. In der Google Play Console: Erstelle Anmeldedaten für deinen Gameserver. Der OAuth-Clienttyp der Anmeldedaten ist „web“.
  2. Fordern Sie in der Android-App bei der Anmeldung einen Serverauthentifizierungscode für Ihr und geben sie an Ihren Server weiter.
  3. Auf Ihrem Spieleserver: Serverauthentifizierungscode gegen OAuth-Zugriff austauschen Token mithilfe von Google-Authentifizierungsdiensten und rufen Sie damit REST APIs der Play-Spieldienste

Hinweis

Zunächst musst du dein Spiel in der Google Play Console, wie unter Richte die Google Play-Spieldienste ein und integriere die Anmeldung für Play-Spieldienste in dein Spiel.

Eine zugehörige serverseitige Webanwendung für Ihr Spiel erstellen

Die Google Play-Spieldienste bieten keinen Back-End-Support für Webspiele. Es bietet jedoch Backend-Server-Unterstützung, für den Android-Spieleserver.

Wenn Sie die Methode REST APIs für Google Play-Spieldienste in Ihrer serverseitigen App gehen Sie so vor:

  1. Rufen Sie in der Google Play Console für Ihr Spiel Play-Spieldienste > Einrichtung und Verwaltung > Konfiguration auf.
  2. Wählen Sie Anmeldedaten hinzufügen aus, um die Seite Anmeldedaten hinzufügen aufzurufen. Wählen Sie als Anmeldedatentyp Game server (Gameserver) aus und fahren Sie mit dem Abschnitt Authorization (Autorisierung) fort.
    1. Wenn Ihr Game-Server bereits eine OAuth-Client-ID hat, wählen Sie sie aus dem Drop-down-Menü aus. Nachdem Sie Ihre Änderungen gespeichert haben, fahren Sie mit dem nächsten Abschnitt fort.
    2. Wenn du noch keine OAuth-Client-ID für deinen Spieleserver hast, kannst du eine erstellen.
      1. Klicken Sie auf OAuth-Client erstellen und folgen Sie dem Link OAuth-Client-ID erstellen.
      2. Daraufhin wird die Seite OAuth-Client-ID erstellen der Google Cloud Platform für das Cloud Platform-Projekt Ihres Spiels geöffnet.
      3. Füllen Sie das Formular auf der Seite aus und klicken Sie auf „Erstellen“. Legen Sie den Anwendungstyp auf „Webanwendung“ fest.
      4. Kehren Sie zum Abschnitt Autorisierung der Seite „Anmeldedaten hinzufügen“ zurück, wählen Sie den neu erstellten OAuth-Client aus und speichern Sie Ihre Änderungen.

Server-Authentifizierungscode abrufen

So rufen Sie einen Server-Authentifizierungscode ab, den Ihr Spiel für Zugriffstokens auf Ihrem Back-End-Server verwenden kann:

  1. Rufen Sie requestServerSideAccess über den Client an.

    1. Verwenden Sie die für Ihren Spieleserver registrierte OAuth-Client-ID und nicht die OAuth-Client-ID Ihrer Android-App.
    2. Optional: Wenn Ihr Spieleserver Offlinezugriff (langlebigen Zugriff mit einem Aktualisierungstoken) auf die Play-Spieldienste benötigt, können Sie den Parameter „forceRefreshToken“ auf „true“ setzen.
    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. Senden Sie das OAuth-Authentifizierungscode-Token an Ihren Backend-Server, damit es eingetauscht werden kann, die Spieler-ID anhand der REST APIs der Play-Spieldienste überprüft und dann mit Ihrem Spiel authentifiziert werden kann.

Server-Authentifizierungscode gegen ein Zugriffstoken auf dem Server austauschen

Sende den Serverautorisierungscode an deinen Backend-Server, um ihn gegen Zugriffs- und Aktualisierungstokens einzutauschen. Verwenden Sie das Zugriffstoken, um die Google Play Games Services API im Namen des Spielers aufzurufen. Optional: Speichern Sie das Aktualisierungstoken, um nach Ablauf des Zugriffstokens ein neues Zugriffstoken zu erhalten.

Im folgenden Code-Snippet wird gezeigt, wie Sie den serverseitigen Code in der Programmiersprache Java implementieren können, um den Serverauthentifizierungscode gegen Zugriffstokens einzutauschen. Dabei wird die Beispielanwendung „clientserverskeleton“ verwendet:

/**
 * 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;
}

REST APIs vom Server aufrufen

Eine vollständige Beschreibung der verfügbaren API-Aufrufe finden Sie unter REST APIs für Google Play Spieledienste.

Hier einige Beispiele für REST API-Aufrufe, die für Sie interessant sein könnten:

Spieler

  • Möchtest du die ID und die Profildaten des angemeldeten Spielers abrufen? Rufe Players.get mit 'me' als ID auf.

Freunde

Du solltest dir unbedingt den Leitfaden Freunde durchlesen, in dem „Freunde“ ausführlicher erklärt wird.

Erfolge

Lesen Sie den Leitfaden zu Erfolgen, in dem die Erfolge erläutert werden. genauer an.

  • Möchtest du eine Liste deiner aktuellen Erfolge aufrufen? Rufen Sie dazu AchievementDefinitions.list auf.
  • Kombiniere das mit einem Aufruf von Achievements.list, um herauszufinden, welche der Spieler freigeschaltet hat.
  • Hat der Spieler einen Erfolg erzielt? Verwende Achievements.unlock, um ihn freizuschalten.
  • Hat der Spieler Fortschritte in Bezug auf einen Teilerfolg gemacht? Verwende Achievements.increment, um den Fortschritt zu melden und herauszufinden, ob der Spieler den Erfolg freigeschaltet hat.
  • Führen Sie eine Fehlerbehebung für ein Spiel durch, das noch nicht in der Produktion ist? Rufe Achievements.reset oder Achievements.resetAll aus den Verwaltungs-APIs auf, um die Erfolge auf den ursprünglichen Zustand zurückzusetzen.

Bestenlisten

In der Anleitung zu Bestenlisten finden Sie weitere Informationen zu Bestenlisten.

  • Möchten Sie eine Liste aller Punktestände in dem Spiel abrufen? Rufen Sie Leaderboards.list auf.
  • Ist der Spieler mit einem Spiel fertig? Sie können die Punktzahl bei Scores.submit einreichen und herausfinden, ob ist das ein neuer Highscore.
  • Möchtest du eine Bestenliste anzeigen? Rufen Sie die Daten aus Scores.list ab und zeigen Sie sie dem Nutzer an.
  • Mit Scores.listWindow kannst du eine Auswahl von Punktzahlen finden, die dem Highscore des Nutzers nahekommen.
  • Wenn Sie weitere Informationen zum Punktestand eines Spielers in einer bestimmten Bestenliste erhalten möchten (z. B. ob er zu den besten 12 % aller Spieler gehört), rufen Sie Scores.get auf.
  • Entwickeln Sie ein Spiel? Rufen Sie Scores.reset aus der Verwaltung auf. APIs zum Zurücksetzen aller Punktzahlen für diesen Spieler aus einer bestimmten Bestenliste