Diese Seite wurde von der Cloud Translation API übersetzt.

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

Wenn in diesem Szenario die wenn sich der Spieler erfolgreich anmeldet, kannst du einen speziellen Einmalcode anfordern, (genannt Serverauthentifizierungscode) aus dem Play Games Services v2 SDK, das der Client an den Server übergibt. Dann tauschen Sie auf dem Server Der Autorisierungscode des Servers für ein OAuth 2.0-Token, mit dem der Server Aufrufe an die Google Play-Spieldienste API

Weitere Informationen zum Hinzufügen einer Log-in in deinen Spielen findest du unter Anmeldung in Android-Spielen

Für den Offlinezugriff sind die folgenden Schritte erforderlich:

In der Google Play Console: Erstelle Anmeldedaten für deinen Gameserver. Die 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 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.

Verknüpfte serverseitige Webanwendung für Ihr Spiel erstellen

Google Play-Spieldienste bieten kein Backend Unterstützung 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:

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. Verfügt Ihr Spieleserver bereits über eine OAuth-Client-ID, 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 gegen ein Zugriffstoken auf dem Server austauschen

Senden Sie den Autorisierungscode des Servers an Ihren Backend-Server, um Zugriffs- und Aktualisierungstokens zu erhalten. 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.

Das folgende Code-Snippet zeigt, wie Sie den serverseitigen Code in der Java- Programmiersprache, um den Server-Authentifizierungscode gegen Zugriffstoken auszutauschen. Es ist mithilfe der 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

Weitere Informationen finden Sie unter REST APIs für Google Play-Spieldienste. 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? Rufen Sie Players.get auf. mit der ID 'me'.

Freunde

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

Möchtest du die Freundesliste des Spielers abrufen? Rufen Sie Players.list mit 'friends_all' als collection.
Hast du Zugriff auf die Freundesliste? Rufen Sie Players.get für me auf und sehen Sie sich das Feld profileSettings.friendsListVisibility in der Antwort an.

Erfolge

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

Möchten Sie eine Liste Ihrer aktuellen Erfolge sehen? Sie können AchievementDefinitions.list aufrufen.
Kombinieren Sie dies mit einem Aufruf von Achievements.list, um herauszufinden, welche der Spieler freigeschaltet haben.
Hat der Spieler einen Erfolg erzielt? Verwenden Sie Achievements.unlock, um es freizuschalten!
Hat der Spieler Fortschritte in Bezug auf einen Teilerfolg gemacht? Verwenden Sie Achievements.increment: über den Fortschritt zu informieren (und herauszufinden, ob der Spieler es freigeschaltet hat).
Führen Sie eine Fehlerbehebung für ein Spiel durch, das noch nicht in der Produktion ist? Anrufen Achievements.reset oder Achievements.resetAll in den Management APIs um Erfolge auf ihren 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 fertig mit einem Spiel? 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.
Verwenden Sie Scores.listWindow, um eine Auswahl von Punktzahlen zu finden, die nahe an der Highscore des Nutzers liegen.
Um mehr Informationen über die Punktzahl eines Spielers in einer bestimmten Bestenliste zu erhalten, z. B. wenn das Spieler zu den besten 12% aller Spieler gehört), rufen Sie Scores.get auf.
Möchtest du Fehler in einem Spiel beheben? Rufen Sie Scores.reset aus der Verwaltung auf. APIs zum Zurücksetzen aller Punktzahlen für diesen Spieler aus einer bestimmten Bestenliste