Serverseitiger Zugriff auf die Google Play-Spieldienste

Wir empfehlen, `PgsGamesSignInClient` zu verwenden, um Spieler zu authentifizieren und die Identität des Spielers sicher an den Back-End- Server zu übergeben. 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.

Sobald sich der Spieler erfolgreich authentifiziert hat, können Sie im nativen SDK der Play-Spieldienste v2 (Beta) einen speziellen Einmalcode (Serverautorisierungscode) anfordern, den der Client an den Server übergibt. Tauschen Sie dann auf dem Server den Serverautorisierungscode gegen ein OAuth 2.0-Token ein, mit dem der Server Aufrufe an die Google Play Games-Dienste API senden kann.

Weitere Informationen zum Hinzufügen der Authentifizierung in Ihren Spielen finden Sie unter Plattformauthentifizierung.

Für den Offlinezugriff sind die folgenden Schritte erforderlich:

  1. Google Play Console: Erstellen Sie Anmeldedaten für Ihren Gameserver. Der OAuth-Clienttyp der Anmeldedaten ist „Web“.
  2. Android-App: Fordern Sie im Rahmen der Plattformauthentifizierung einen Serverautorisierungscode für die Anmeldedaten Ihres Servers an und übergeben Sie ihn an Ihren Server. Der PgsGamesSignInClient kann drei OAuth 2.0-Bereiche anfordern, wenn er serverseitigen Zugriff auf die Web-APIs der Play Games-Dienste anfordert. Die optionalen Bereiche sind PGS_AUTH_SCOPE_EMAIL, PGS_AUTH_SCOPE_PROFILE und PGS_AUTH_SCOPE_OPENID. Die beiden Standardbereiche sind DRIVE_APPFOLDER und GAMES_LITE.
  3. Auf Ihrem Gameserver: Tauschen Sie den Serverautorisierungscode mit den Google-Authentifizierungsdiensten gegen ein OAuth-Zugriffstoken ein und rufen Sie damit die Play Games Services REST APIs auf.

Hinweis

Sie müssen Ihr Spiel zuerst in der Google Play Console hinzufügen, wie unter Google Play Games-Dienste einrichten mit Ihrem Spiel beschrieben.

Serverseitige Web-App erstellen

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

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

  1. Wählen Sie in der Google Play Console ein Spiel aus.
  2. Rufen Sie Play Games-Dienste > Einrichtung und Verwaltung > Konfiguration auf.
  3. Wählen Sie Anmeldedaten hinzufügen aus, um zur Seite Anmeldedaten hinzufügen zu gelangen. Wählen Sie Gameserver als Anmeldedatentyp aus und fahren Sie mit dem Abschnitt Autorisierung fort.
    1. Wenn Ihr Gameserver bereits eine OAuth-Client-ID hat, wählen Sie sie im Drop-down-Menü aus. Nachdem Sie die Änderungen gespeichert haben, fahren Sie mit dem nächsten Abschnitt fort.
    2. Wenn Sie keine vorhandene OAuth-Client-ID für Ihren Gameserver haben, können Sie eine erstellen.
      1. Klicken Sie auf OAuth-Client erstellen und folgen Sie dem Link OAuth-Client-ID erstellen.
      2. Sie werden zur Seite OAuth-Client-ID erstellen der Google Cloud Platform für Ihr Projekt weitergeleitet, 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 die Änderungen.

Serverautorisierungscode abrufen

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

  1. Rufen Sie PgsGamesSignInClient_requestServerSideAccess vom Client auf.
    1. Verwenden Sie die OAuth-Client-ID, die für Ihren Gameserver registriert ist , und nicht die OAuth-Client-ID Ihrer Android-App.
    2. Optional: Wenn Ihr Gameserver Offlinezugriff (langer Zugriff mit einem Aktualisierungstoken) auf die Play Games-Dienste benötigt, können Sie den Parameter force_refresh_token auf „true“ setzen.

  2. Optional: Im Rahmen der Authentifizierung sollten neue Nutzer einen einzigen Zustimmungsbildschirm für zusätzliche Bereiche sehen. Wenn Sie die Zustimmung erteilen, legen Sie den PgsAuthScope scopes Parameter mit PGS_AUTH_SCOPE_EMAIL, PGS_AUTH_SCOPE_PROFILE und PGS_AUTH_SCOPE_OPENID OAuth-Bereichen fest. Wenn Nutzer die Zustimmung ablehnen, werden nur die beiden Standardbereiche DRIVE_APPFOLDER und GAMES_LITE an das Back-End gesendet.

    Zustimmungsbildschirm für zusätzliche OAuth-Bereiche.
    Zustimmungsbildschirm für zusätzliche OAuth-Bereiche. Zum Vergrößern klicken.

     // #include "google/games/pgs_games_sign_in_client.h"
 // 1. Define the Callback
 // This function is called when the server-side access request completes.
 // It provides the authorization code (on success) or an error (on failure).
 void OnServerSideAccessCallback(void* context, PgsError error, const char* serverAuthCode) {
     if (error == PgsError_Success) {
         if (serverAuthCode != nullptr) {
             __android_log_print(ANDROID_LOG_INFO, "Games",
                 "Received Server Auth Code: %s", serverAuthCode);
             // Send 'serverAuthCode' to your backend server immediately.
             // Your server will exchange this code for an OAuth access token.
         }
     } else {
         __android_log_print(ANDROID_LOG_ERROR, "Games",
          "Failed to get server auth code. Error: %d", error);
     }
 }
 // 2. Define the Wrapper Function
 void RequestServerAccess(PgsGamesSignInClient* signInClient) {
     if (signInClient == nullptr) {
         return;
     }
     // This must match the "Web client ID" from your Google Cloud Console
     // (linked to your Play Console Game Server Credential).
     const char* SERVER_CLIENT_ID = "xxxx";
     // Set to 'true' if your server needs a Refresh Token (long-lived access).
     // Set to 'false' if you only need an Access Token (short-lived).
     bool forceRefreshToken = false;
     // Call the API
     PgsGamesSignInClient_requestServerSideAccess(
        signInClient,
        SERVER_CLIENT_ID,
        forceRefreshToken,
        OnServerSideAccessCallback, // The callback defined
        nullptr                     // User context (optional, passed to callback)
     );
 }
 // 3. Example Usage
 void TriggerSignInProcess(PgsGamesClient* gamesClient) {
      // Obtain the Sign-In Client from the main Games Client
      PgsGamesSignInClient* signInClient = PgsGamesClient_getSignInClient(gamesClient);
      RequestServerAccess(signInClient);
 }

  3. Senden Sie das OAuth-Autorisierungscode-Token an Ihren Backend-Server, damit es ausgetauscht werden kann, die Spieler-ID anhand der REST APIs der Play Games-Dienste überprüft und dann mit Ihrem Spiel authentifiziert werden kann.

Serverautorisierungscode senden

Senden Sie den Serverautorisierungscode an Ihren Back-End-Server, um ihn gegen Zugriffs- und Aktualisierungstokens einzutauschen. Verwenden Sie das Zugriffstoken, um die Play Games-Dienste API im Namen des Spielers aufzurufen, und speichern Sie optional das Aktualisierungstoken, um ein neues Zugriffstoken zu erhalten, wenn das Zugriffstoken abläuft.

Weitere Informationen zu Spieler-IDs finden Sie unter Spieler-IDs der nächsten Generation.

Das folgende Code-Snippet zeigt, wie Sie den serverseitigen Code in der Programmiersprache C++ implementieren können, um den Serverautorisierungscode gegen Zugriffstokens einzutauschen.

Java

/**
 * Exchanges the authcode for an access token credential. The credential
 * is 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 Cloud
    // 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();

    TokenVerifier(tokenResponse);

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

Sie können die OAuth-Bereiche mit den Google API-Clientbibliotheken in Java oder Python abrufen, um das GoogleIdTokenVerifier Objekt zu erhalten. Das folgende Code-Snippet zeigt die Implementierung in der Programmiersprache Java.

Java

import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken.Payload;
import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier;

/**
 * Gets the GoogleIdTokenVerifier object and additional OAuth scopes.
 * If additional OAuth scopes are not requested, the idToken will be null.
 *
 * @param tokenResponse - the tokenResponse passed from the exchangeAuthCode
 *                        function.
 *
 **/

void TokenVerifier(GoogleTokenResponse tokenResponse) {

    string idTokenString = tokenResponse.getIdToken();

    GoogleIdTokenVerifier verifier = new GoogleIdTokenVerifier.Builder(transport, jsonFactory)
        // Specify the WEB_CLIENT_ID of the app that accesses the backend:
        .setAudience(Collections.singletonList(WEB_CLIENT_ID))
        // Or, if multiple clients access the backend:
        //.setAudience(Arrays.asList(WEB_CLIENT_ID_1, WEB_CLIENT_ID_2, WEB_CLIENT_ID_3))
        .build();

    GoogleIdToken idToken = verifier.verify(idTokenString);

    // The idToken can be null if additional OAuth scopes are not requested.
    if (idToken != null) {
        Payload payload = idToken.getPayload();

    // Print user identifier
    String userId = payload.getSubject();
    System.out.println("User ID: " + userId);

    // Get profile information from payload
    String email = payload.getEmail();
    boolean emailVerified = Boolean.valueOf(payload.getEmailVerified());
    String name = (String) payload.get("name");
    String pictureUrl = (String) payload.get("picture");
    String locale = (String) payload.get("locale");
    String familyName = (String) payload.get("family_name");
    String givenName = (String) payload.get("given_name");

    // This ID is unique to each Google Account, making it suitable for use as
    // a primary key during account lookup. Email is not a good choice because
    // it can be changed by the user.
    String sub = payload.getSubject();

    // Use or store profile information
    // ...

    } else {
      System.out.println("Invalid ID token.");
    }
}

REST APIs vom Server aufrufen

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

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

Spieler

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

Erfolge

Weitere Informationen finden Sie in der Anleitung zu Erfolgen.

  • Rufen Sie `AchievementDefinitions.list` auf, um eine Liste der aktuellen Erfolge zu erhalten.

  • Kombinieren Sie das mit einem Aufruf von `Achievements.list` , um herauszufinden, welche Erfolge der Spieler freigeschaltet hat.

  • Rufen Sie `Achievements.unlock` auf, um einen Spielerfolg 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 Produktion ist, können Sie Achievements.reset oder Achievements.resetAll über die Management APIs aufrufen, um Erfolge auf ihren ursprünglichen Zustand zurückzusetzen.