Diese Seite wurde von der Cloud Translation API übersetzt.

Serverseitiger Zugriff auf die Google Play-Spieldienste

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

In diesem Szenario kannst du 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 die Google Play-Spieldienste API aufrufen kann.

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

Für den Offlinezugriff sind die folgenden Schritte erforderlich:

In der Google Play Console: Erstellen Sie Anmeldedaten für Ihren Gameserver. Der OAuth-Clienttyp der Anmeldedaten ist „web“.
In der Android-App: Fordere bei der Anmeldung einen Serverauthentifizierungscode für die Anmeldedaten deines Servers an und leite ihn an deinen Server weiter.
Auf Ihrem Gameserver: Tauschen Sie den Serverautorisierungscode mithilfe der Google Auth-Dienste gegen ein OAuth-Zugriffstoken aus und rufen Sie dann die REST APIs der Play-Spieldienste auf.

Hinweis

Sie müssen Ihr Spiel zuerst in der Google Play Console hinzufügen, wie im Abschnitt Google Play-Spieldienste einrichten beschrieben, und die Anmeldung über die Google Play-Spieldienste in Ihr Spiel einbinden.

Serverseitige Webanwendung erstellen

Die Google Play-Spieldienste bieten keinen Backend-Support für Webspiele. Es bietet jedoch Back-End-Serverunterstützung für den Server Ihres Android-Spiels.

Wenn Sie die REST APIs für Google Play-Spieldienste in Ihrer serverseitigen App verwenden möchten, gehen Sie so vor:

Wählen Sie in der Google Play Console ein Spiel aus.
Gehen Sie zu Play-Spieldienste > Einrichtung und Verwaltung > Konfiguration.
Wählen Sie Anmeldedaten hinzufügen aus, um die Seite Anmeldedaten hinzufügen aufzurufen. Wählen Sie als Anmeldedatentyp Game Server aus und fahren Sie mit dem Abschnitt 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 Sie noch keine OAuth-Client-ID für Ihren Game-Server haben, können Sie 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-Plattform für das Projekt angezeigt, das mit Ihrem Spiel verknüpft ist.
  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.

Serverauthentifizierungscode abrufen

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

Rufen Sie requestServerSideAccess über den Client an.

Verwenden Sie die OAuth-Client-ID, die für Ihren Gameserver registriert ist, und nicht die OAuth-Client-ID Ihrer Android-Anwendung.
Optional: Wenn Ihr Gameserver einen Offlinezugriff (langlebigen Zugriff mit einem Aktualisierungstoken) auf die Play-Spieledienste 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.
    }
});

Senden Sie das OAuth-Authentifizierungscode-Token an Ihren Backend-Server, damit es eingetauscht werden kann. Die Spieler-ID wird dann anhand der REST APIs der Play-Spieldienste überprüft und anschließend mit Ihrem Spiel authentifiziert.

Serverauthentifizierungscode senden

Senden Sie den Serverauthentifizierungscode an Ihren Backend-Server, um ihn gegen Zugriffs- und Aktualisierungstokens einzutauschen. Verwende das Zugriffstoken, um die Play Spiele-Dienste API im Namen des Spielers aufzurufen, und speichere optional das Aktualisierungstoken, um ein neues Zugriffstoken abzurufen, wenn das aktuelle abläuft.

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

REST APIs vom Server aufrufen

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

Beispiele für nützliche REST API-Aufrufe:

Spieler

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

Friends

Weitere Informationen finden Sie im Hilfeartikel Freunde.

Rufe Players.list mit friends_all als collection auf, um die Freundesliste des Spielers abzurufen.
Wenn du prüfen möchtest, ob du Zugriff auf eine Freundesliste hast, rufe Players.get mit me als playerID auf und sieh dir das Feld profileSettings.friendsListVisibility in der Antwort an.

Erfolge

Weitere Informationen finden Sie im Hilfeartikel Erfolge.

Rufen Sie AchievementDefinitions.list auf, um eine Liste der aktuellen Erfolge zu erhalten.
Kombiniere das mit einem Aufruf zu Achievements.list, um herauszufinden, welche der Spieler freigeschaltet hat.
Rufen Sie Achievements.unlock auf, um einen Spielererfolg freizuschalten.
Rufen Sie Achievements.increment auf, um den Fortschritt bei einem Erfolg zu melden und herauszufinden, ob der Spieler ihn freigeschaltet hat.
Wenn Sie ein Spiel debuggen, das noch nicht in der Produktionsphase ist, können Sie über die Management APIs Achievements.reset oder Achievements.resetAll aufrufen, um die Erfolge auf den ursprünglichen Zustand zurückzusetzen.

Bestenlisten

Weitere Informationen zu Bestenlisten

Möchtest du eine Liste aller Bestenlisten im Spiel aufrufen? Rufen Sie Leaderboards.list auf.
Wenn ein Spieler mit einem Spiel fertig ist, können Sie seinen Punktestand an Scores.submit senden und herausfinden, ob es sich um einen neuen Highscore handelt.
Wenn Sie eine Bestenliste anzeigen möchten, 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.
Wenn Sie ein Spiel debuggen, können Sie über die Management APIs Scores.reset aufrufen, um alle Punkte für diesen Spieler aus einer bestimmten Bestenliste zurückzusetzen.