Serverseitigen Zugriff auf Google Play-Spieldienste aktivieren

Wir empfehlen, Spieler zu authentifizieren und die Identität des Spielers sicher an den Back-End-Server zu übergeben. So kann das Spiel die Identität des Spielers und andere Daten sicher abrufen, ohne dass es während des Durchlaufs des Geräts zu Manipulationen gebracht werden könnte.

In diesem Szenario können Sie, sobald sich der Spieler erfolgreich angemeldet hat, einen speziellen Einmalcode (Serverauthentifizierungscode) vom Play Spiele Services Version 2 SDK anfordern, das der Client an den Server übergibt. Tauschen Sie dann auf dem Server den Server-Authentifizierungscode gegen ein OAuth 2.0-Token aus, mit dem der Server Aufrufe an die Google Play Games Services API senden kann.

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

Für den Offlinezugriff sind folgende Schritte erforderlich:

  1. In der Google Play Console: Erstellen Sie Anmeldedaten für Ihren Spieleserver. Der OAuth-Clienttyp der Anmeldedaten lautet „web“.
  2. In der Android-App: Fordere während der Anmeldung einen Server-Authentifizierungscode als Anmeldedaten für deinen Server an und übergib ihn an deinen Server.
  3. Auf Ihrem Spieleserver: Tauschen Sie den Authentifizierungscode des Servers mithilfe von Google-Authentifizierungsdiensten gegen ein OAuth-Zugriffstoken aus und rufen Sie damit die REST APIs der Play-Spieldienste auf.

Hinweis

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

Verknüpfte serverseitige Webanwendung für Ihr Spiel erstellen

Die Google Play-Spieldienste bieten keine Back-End-Unterstützung für Webspiele. Sie bietet jedoch Back-End-Server-Unterstützung für den Server Ihres Android-Spiels.

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

  1. Rufen Sie in der Google Play Console in Ihrem 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 Spieleserver aus und fahren Sie mit dem Abschnitt Autorisierung fort.
    1. Wenn Ihr Spieleserver 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 Spieleserver haben, können Sie eine erstellen.
      1. Klicken Sie auf OAuth-Client erstellen und folgen Sie dem Link OAuth-Client-ID erstellen.
      2. Dadurch gelangen Sie auf die Google Cloud Platform-Seite OAuth-Client-ID erstellen für das zugehörige Cloud Platform-Projekt Ihres Spiels.
      3. Füllen Sie das Formular aus und klicken Sie auf „Erstellen“. Legen Sie als Anwendungstyp „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 Server-Authentifizierungscode ab, den Ihr Spiel für Zugriffstoken auf Ihrem Back-End-Server verwenden kann:

  1. Rufen Sie requestServerSideAccess vom Client auf.

    1. Achten Sie darauf, die OAuth-Client-ID zu verwenden, die für Ihren Spieleserver registriert ist, und nicht die OAuth-Client-ID Ihrer Android-App.
    2. Optional: Wenn für Ihren Spieleserver ein Offline-Zugriff auf Play Spiele-Dienste erforderlich ist (langlebiger Zugriff mit einem Aktualisierungstoken), 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 Back-End-Server, damit es ausgetauscht und die Spieler-ID mit den Play Spiele Services REST APIs überprüft und dann bei Ihrem Spiel authentifiziert werden kann.

Serverauthentifizierungscode gegen ein Zugriffstoken auf dem Server austauschen

Senden Sie den Serverauthentifizierungscode an Ihren Back-End-Server, um ein Zugriffs- und Aktualisierungstoken auszutauschen. Verwenden Sie das Zugriffstoken, um die Google Play Games Services API im Namen des Players aufzurufen. Optional können Sie das Aktualisierungstoken speichern, um nach Ablauf des Zugriffstokens ein neues Zugriffstoken zu erhalten.

Das folgende Code-Snippet zeigt, wie Sie den serverseitigen Code in der Programmiersprache Java implementieren können, um den Serverauthentifizierungscode gegen Zugriffstoken auszutauschen. Dabei wird die Clientserverskeleton-Beispielanwendung 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 aus aufrufen

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

Beispiele für REST API-Aufrufe, die hilfreich sein können:

Spieler

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

Freunde

Lies dir den Leitfaden für Freunde durch, in dem Freunde ausführlicher erläutert werden.

Erfolge

In der Anleitung Erfolge werden die Erfolge ausführlicher erläutert.

  • Möchten Sie eine Liste der aktuellen Erfolge sehen? Sie können AchievementDefinitions.list aufrufen.
  • Kombiniere dies mit einem Aufruf von Achievements.list, um herauszufinden, welche vom Spieler freigeschaltet wurden.
  • Hat der Spieler einen Erfolg erhalten? Mit Achievements.unlock können Sie sie freischalten.
  • Hat der Spieler Fortschritte bei einem teilweisen Erfolg gemacht? Mit Achievements.increment können Sie den Fortschritt melden und herausfinden, ob der Spieler ihn freigeschaltet hat.
  • Wird ein Spiel debuggen, das sich noch nicht in der Produktion befindet? Versuchen Sie, Achievements.reset oder Achievements.resetAll über die Management APIs aufzurufen, um die Erfolge in den ursprünglichen Zustand zurückzusetzen.

Bestenlisten

Lies dir den Leitfaden Bestenlisten durch, in dem Bestenlisten ausführlicher erläutert werden.

  • Möchtest du eine Liste aller Ergebnistafeln im Spiel erhalten? Rufen Sie Leaderboards.list auf.
  • Ist der Spieler mit einem Spiel fertig? Sie können deren Punktzahl an Scores.submit senden und herausfinden, ob es sich um eine neue Highscore handelt.
  • Möchtest du eine Bestenliste sehen? Rufen Sie die Daten aus Scores.list ab und zeigen Sie sie dem Nutzer.
  • Mit Scores.listWindow finden Sie eine Auswahl von Spielständen in der Nähe des Highscores des Nutzers.
  • Rufen Sie Scores.get auf, um weitere Informationen zur Punktzahl eines Spielers in einer bestimmten Bestenliste zu erhalten, beispielsweise wenn der Spieler zu den besten 12% aller Spieler gehört.
  • Wird ein Spiel debuggen? Rufen Sie Scores.reset über die Management APIs auf, um alle Punktzahlen für diesen Spieler aus einer bestimmten Bestenliste zurückzusetzen.