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 weiterzugeben. Dies ermöglicht um die Identität und andere Daten des Spielers sicher abzurufen, während das Gerät möglicherweise manipuliert wird.

In diesem Szenario können Sie nach erfolgreicher Anmeldung einen speziellen Einmalcode (auch als Serverauthentifizierungscode bezeichnet) von Play Spiele Services v2 SDK, das der Client an den Server übergibt. Auf dem Server den Autorisierungscode des Servers gegen ein OAuth 2.0-Token austauschen, mit dem der Server Google Play Games Services API aufrufen

Weitere Informationen zum Hinzufügen einer Log-in in deinen Spielen findest du unter Für Android-Spiele anmelden

Für den Offlinezugriff sind die folgenden Schritte erforderlich:

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

Hinweis

Zunächst musst du dein Spiel in der Google Play Console, wie unter Google Play-Spieldienste einrichten Integriere die Anmeldung für die Play-Spieldienste in dein Spiel.

Serverseitige Webanwendung erstellen

Google Play-Spieldienste bieten kein Backend Webspiele unterstützt. 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:

Rufe in der Google Play Console in deinem Spiel Play-Spieldienste > Einrichtung und Verwaltung > Konfiguration.
Wählen Sie Anmeldedaten hinzufügen aus. Daraufhin gelangen Sie zur Seite Anmeldedaten hinzufügen. Wählen Sie als Anmeldedatentyp Game server (Gameserver) aus und fahren Sie mit dem Abschnitt Authorization (Autorisierung) fort.
1. Falls Ihr Spieleserver bereits über eine OAuth-Client-ID verfügt, wählen Sie diese im 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. Dadurch gelangen Sie zur Google Cloud Platform-Seite OAuth-Client-ID erstellen für das mit Ihrem Spiel verknüpfte Cloud Platform-Projekt.
  3. Füllen Sie das Formular der Seite aus und klicken Sie auf „Erstellen“. Legen Sie als Anwendungstyp „Webanwendung“ fest.
  4. Kehren Sie zum Abschnitt Autorisierung hinzufügen auf der Seite zurück, wählen Sie den neu erstellten OAuth-Client aus und speichern Sie die Änderungen.

Server-Authentifizierungscode abrufen

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

Rufen Sie requestServerSideAccess über den Client auf.

Verwenden Sie die für Ihren Spieleserver registrierte OAuth-Client-ID und nicht die OAuth-Client-ID Ihrer Android-App.
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.
    }
});

Senden Sie das OAuth-Authentifizierungscode-Token an Ihren Back-End-Server, damit es ausgetauscht werden kann. Die Spieler-ID wird mit den REST APIs der Play-Spieldienste verifiziert und anschließend mit Ihrem Spiel authentifiziert.

Server-Authentifizierungscode senden

Senden Sie den Autorisierungscode des Servers an Ihren Backend-Server, um Zugriff zu erhalten Aktualisierungstokens. Mit dem Zugriffstoken die Play Games Services API für Folgendes aufrufen: im Namen des Spielers zu speichern und optional das Aktualisierungstoken zu speichern, um ein neues Zugriffs-Token, wenn es abläuft.

Das folgende Code-Snippet zeigt, wie Sie den serverseitigen Code der Programmiersprache Java, um den Autorisierungscode des Servers gegen den Zugriff auszutauschen Tokens. Dabei werden die Beispiel-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;
}

REST APIs über den Server aufrufen

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

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

Spieler

Möchten Sie die ID und die Profildaten des angemeldeten Spielers abrufen? [Players.get][] anrufen mit 'me' als ID.

Friends

Weitere Informationen findest du im Leitfaden für Freunde.

Um die Freundesliste des Spielers abzurufen, rufe Players.list mit friends_all als collection.
Um zu überprüfen, ob du Zugriff auf eine Freundesliste hast, rufe Players.get mit me als playerID und sehen Sie sich profileSettings.friendsListVisibility in der Antwort ein.

Erfolge

Weitere Informationen finden Sie im Leitfaden Erfolge.

Eine Liste Ihrer aktuellen Erfolge erhalten Sie unter AchievementDefinitions.list erreicht werden.
Kombinieren Sie dies mit einem Aufruf an Achievements.list um herauszufinden, welche der Spieler freigeschaltet hat.
Anruf Achievements.unlock um einen Spielererfolg freizuschalten.
Anruf Achievements.increment um den Fortschritt bei einem Erfolg zu melden und herauszufinden, ob der Spieler ihn freigeschaltet hat.
Wenn Sie eine Fehlerbehebung für ein Spiel durchführen, das noch nicht in der Produktion ist, können Sie Achievements.reset oder Achievements.resetAll über die Management APIs, um Erfolge auf ihren ursprünglichen Zustand zurückzusetzen.

Bestenlisten

Weitere Informationen zu Bestenlisten

Möchten Sie eine Liste aller Punktestände in dem Spiel abrufen? Rufen Sie die Leaderboards.list:
Wenn ein Spieler ein Spiel beendet hat, können Sie seine Punktzahl an Scores.submit um herauszufinden, ob es einen neuen Highscore gibt.
Um eine Bestenliste anzuzeigen, rufen Sie die Daten von Scores.list und sie den Nutzenden zeigen.
Verwenden Sie Scores.listWindow. um eine Reihe von Punktzahlen zu finden, die nahe an der Highscore des Nutzers liegen.
Um weitere Informationen zu den Punktzahlen eines Spielers in einer bestimmten Bestenliste zu erhalten Wenn sich der Spieler z. B. zu den besten 12% aller Spieler befindet, rufen Sie folgenden Befehl auf: Scores.get:
Wenn Sie Fehler in einem Spiel beheben, können Sie Scores.reset von den Management-APIs ändern, um alle Punktzahlen für diesen Spieler von einem bestimmten Leaderboard an.