Serverseitigen Zugriff auf die Google Play-Spieldienste aktivieren

Nach der Einstellung der Google-Anmeldung-API wird das games v1 SDK im Jahr 2026 entfernt. Ab Februar 2025 kannst du bei Google Play keine Titel mehr veröffentlichen, die neu in Games SDK V1 integriert wurden. Wir empfehlen, stattdessen das Games SDK V2 zu verwenden.
Bestehende Titel mit den vorherigen Integrationen für Spiele v1 funktionieren zwar noch einige Jahre, aber wir empfehlen Ihnen, ab Juni 2025 zu Version 2 zu migrieren.
In diesem Leitfaden wird die Verwendung des Play Games Services SDK V1 beschrieben. Informationen zur neuesten SDK-Version finden Sie in der Dokumentation zu Version 2.

Wenn Ihr Spiel einen Backend-Server verwendet, empfehlen wir, Google Log-in zur Authentifizierung von Spielern und zur sicheren Übermittlung der Identität des Spielers an den Backend-Server zu verwenden. So kann Ihr Spiel die Identität des Spielers und andere Daten sicher abrufen, ohne dass sie während der Übertragung über das Gerät manipuliert werden können.

In diesem Fall wird der Spieler wie gewohnt aufgefordert, sich in Google Play Spiele anzumelden. Wenn sich der Spieler erfolgreich anmeldet, enthält das GoogleSignInAccount-Objekt einen speziellen Einmalcode (den Server-Autorisierungscode), den der Client an den Server übergibt. Tauschen Sie dann auf dem Server den Server-Autorisierungscode gegen ein OAuth 2.0-Token ein, mit dem der Server Aufrufe der Google Play-Spieldienste-API ausführen kann.

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

Ein detailliertes Codebeispiel für die Authentifizierung von Spielern mit der Google-Anmeldung finden Sie im clientserverskeleton-Beispiel auf GitHub.

Die folgenden Schritte sind für den Offlinezugriff erforderlich:

1. Erstellen Sie in der Google Play Console Anmeldedaten für Ihren Spielserver. Der OAuth-Clienttyp der Anmeldedaten ist „web“.
2. In der Android-App: Fordern Sie im Rahmen der Anmeldung einen Serverautorisierungscode für die Anmeldedaten Ihres Servers an und geben Sie ihn an Ihren Server weiter.
3. Auf Ihrem Spielserver: Tauschen Sie den Serverautorisierungscode mit Google-Authentifizierungsdiensten gegen ein OAuth-Zugriffstoken ein und rufen Sie damit die REST APIs der Play-Spieldienste auf.

Hinweis

Bevor Sie die Google-Anmeldung in Ihr Spiel einbinden können, müssen Sie Ihr Spiel zuerst in der Google Play Console hinzufügen, wie unter Google Play-Spieldienste einrichten beschrieben.

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

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

Wenn Sie die REST APIs for Google Play Games services in Ihrer serverseitigen App verwenden möchten, gehen Sie so vor:

1. Erstellen Sie im Abschnitt Verknüpfte Apps der Google Play Console eine zugehörige Web-App für Ihr Spiel. launch_url wird für diesen Ablauf nicht verwendet und kann leer gelassen werden.
2. So rufen Sie die Anmeldedaten für Ihre App ab:
   1. Klicken Sie in der Google Play Console bei Ihrem Spiel auf Spieldetails.
   2. Scrolle nach unten zum Abschnitt API Console-Projekt und klicke auf den Link zum API Console-Projekt.
   3. Laden Sie in der Google API Console auf der Seite APIs & Services > Anmeldedaten die Datei client_secret.json für Ihre Web-App herunter und speichern Sie sie an einem Ort, auf den Ihr Server zugreifen kann. Notieren Sie sich die Client-ID der Anmeldedaten zur späteren Verwendung.
3. Starte deine serverseitige App neu, damit sie Anfragen von der Client-App deines Spiels annehmen kann.

Anmeldung auf dem Client durchführen

Die Klasse GoogleSignInClient ist der Haupteinstiegspunkt, um das Konto des aktuell angemeldeten Spielers abzurufen und den Spieler anzumelden, falls er dies noch nicht in Ihrer App auf dem Gerät getan hat.

Hinweis: In der Klasse GoogleSignInClient wird die Klasse Task von Google Play-Diensten verwendet, um Ergebnisse asynchron zurückzugeben. Weitere Informationen zur Verwendung von Aufgaben zum Verwalten von Threads finden Sie im Entwicklerleitfaden zur Tasks API.

So erstellen Sie einen Anmeldeclient:

1. Erstellen Sie einen Anmeldeclient über das GoogleSignInOptions-Objekt. Wenn Sie die Anmeldung in GoogleSignInOptions.Builder konfigurieren möchten, müssen Sie GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN angeben.
2. Sie müssen auch angeben, dass für Ihr Spiel ein Autorisierungscode für Ihren Backend-Server erforderlich ist. Rufen Sie dazu die Methode GoogleSignInOptions.Builder.requestServerAuthCode() mit der Client-ID des Servers als Parameter auf. Sie rufen den Autorisierungscode später für Zugriffstokens auf Ihrem Backend-Server ab, wie unter Serverautorisierungscode abrufen beschrieben.
3. Rufen Sie die Methode GoogleSignIn.getClient() auf und übergeben Sie die zuvor konfigurierten Optionen. Wenn der Aufruf erfolgreich ist, gibt die Google Sign-In API eine Instanz von GoogleSignInClient zurück.
4. Sobald Sie die GoogleSignInClient-Instanz erhalten haben, sollten Sie den Spieler über die onResume() der Aktivität im Hintergrund anmelden, wie unter Im Hintergrund anmelden beschrieben.

Beispiel:

private static final int RC_SIGN_IN = 9001;
private GoogleSignInClient mGoogleSignInClient;

private void startSignInForAuthCode() {

  // Client ID for your backend server.
  String webClientId = getString(R.string.webclient_id);

  GoogleSignInOptions signInOption = new
      GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
      .requestServerAuthCode(webClientId)
      .build();

  GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOption);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}

Server-Authentifizierungscode abrufen

Wenn Sie einen Serverautorisierungscode abrufen möchten, den Ihr Spiel für Zugriffstokens auf Ihrem Backend-Server verwenden kann, rufen Sie die Methode getServerAuthCode() für das Objekt GoogleSignInAccount auf, das bei einer erfolgreichen Spieleranmeldung von Google Sign-in zurückgegeben wird.

Beispiel:

// Auth code to send to backend server.
private String mServerAuthCode;

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  if (requestCode == RC_SIGN_IN) {
    GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
    if (result.isSuccess()) {
      mServerAuthCode = result.getSignInAccount().getServerAuthCode();
    } else {
      String message = result.getStatus().getStatusMessage();
      if (message == null || message.isEmpty()) {
        message = getString(R.string.signin_other_error);
      }
      new AlertDialog.Builder(this).setMessage(message)
          .setNeutralButton(android.R.string.ok, null).show();
    }
  }
}

Serverautorisierungscode auf dem Server gegen ein Zugriffstoken eintauschen

Senden Sie den Serverautorisierungscode an Ihren Backend-Server, um ihn gegen Zugriffs- und Aktualisierungstokens einzutauschen. Verwenden Sie das Zugriffstoken, um die Google Play-Spieldienste-API im Namen des Spielers aufzurufen. Optional können Sie das Aktualisierungstoken speichern, um ein neues Zugriffstoken zu erhalten, wenn das Zugriffstoken abläuft.

Im folgenden Code-Snippet sehen Sie, wie Sie den serverseitigen Code in der Programmiersprache Java implementieren können, um den Serverautorisierungscode gegen Zugriffstokens einzutauschen. Dabei wird die Beispiel-App „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;
}

Weitere Informationen zum Zugriff auf Google-APIs von einem Backend-Server im Namen eines angemeldeten Spielers finden Sie unter Serverseitigen Zugriff aktivieren.

Spielerabmeldung verarbeiten

Wenn Sie Spieler aus Ihrem Spiel abmelden möchten, rufen Sie die Methode signOut() für GoogleSignInClient auf. Ein Beispielcode-Snippet finden Sie unter Player abmelden.

REST APIs vom Server aus aufrufen

Eine vollständige Beschreibung der verfügbaren API-Aufrufe finden Sie unter REST APIs for Google Play Games services.

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

Spieler

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

Friends

Weitere Informationen finden Sie im Leitfaden zu Freunden.

• Möchten Sie die Freundesliste des Spielers abrufen? Rufen Sie Players.list mit 'friends_all' als collection auf.
• Haben Sie 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

Weitere Informationen zu Erfolgen finden Sie im Leitfaden zu Erfolgen.

• Möchten Sie eine Liste der aktuellen Erfolge erhalten? Sie können AchievementDefinitions.list aufrufen.
• In Kombination mit einem Aufruf von Achievements.list können Sie herausfinden, welche Erfolge der Spieler freigeschaltet hat.
• Hat der Spieler einen Erfolg erzielt? Verwende Achievements.unlock, um ihn freizuschalten.
• Hat der Spieler Fortschritte in Richtung eines Teilerfolgs gemacht? Verwenden Sie Achievements.increment, um den Fortschritt zu melden und herauszufinden, ob der Spieler den Erfolg freigeschaltet hat.
• Debuggen Sie ein Spiel, das noch nicht in der Produktion ist? Versuchen Sie, Achievements.reset oder Achievements.resetAll über die Management APIs aufzurufen, um Erfolge auf ihren ursprünglichen Zustand zurückzusetzen.

Bestenlisten

Lesen Sie sich den Leitfaden zu Bestenlisten durch, in dem Bestenlisten genauer beschrieben werden.

• Möchtest du eine Liste aller Bestenlisten im Spiel erhalten? Rufen Sie Leaderboards.list auf.
• Hat der Spieler ein Spiel beendet? Sie können den Score mit Scores.submit einreichen und herausfinden, ob es sich um einen neuen Highscore handelt.
• Möchten Sie eine Bestenliste anzeigen? Rufe die Daten aus Scores.list ab und zeige sie dem Nutzer an.
• Mit Scores.listWindow können Sie eine Reihe von Punktzahlen in der Nähe des Highscores des Nutzers abrufen.
• Wenn Sie weitere Informationen zum Score des Spielers in einer bestimmten Bestenliste erhalten möchten, z. B. ob der Spieler zu den besten 12% aller Spieler gehört, rufen Sie Scores.get auf.
• Debuggen Sie ein Spiel? Rufen Sie Scores.reset über die Management APIs auf, um alle Punktzahlen für diesen Spieler aus einer bestimmten Bestenliste zurückzusetzen.