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 Backend-Server zu übergeben. So kann Ihr Spiel die Identität des Spielers und andere Daten sicher abrufen, ohne dass sie beim Durchlaufen des Geräts manipuliert werden können.

Sobald sich der Spieler erfolgreich authentifiziert hat, können Sie über das Play-Spieldienste v2 Native SDK (Beta) einen speziellen Einmalcode (den Server-Autorisierungscode) 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 der Google Play-Spieldienste-API ausführen kann.

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

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 Plattformauthentifizierung einen Serverautorisierungscode für die Anmeldedaten Ihres Servers an und übergeben Sie ihn an Ihren Server. Die PgsGamesSignInClient kann beim Anfordern des serverseitigen Zugriffs auf Play Games Services-Web-APIs drei OAuth 2.0-Bereiche anfordern. 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 Spielserver: Tauschen Sie den Serverautorisierungscode mit den Google-Authentifizierungsdiensten gegen ein OAuth-Zugriffstoken ein 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.

Serverseitige Webanwendung erstellen

Die Google Play-Spieldienste bieten keine Backend-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. Wählen Sie in der Google Play Console ein Spiel aus.
2. Rufen Sie Play-Spieldienste > Einrichtung und Verwaltung > Konfiguration auf.
3. Wählen Sie Anmeldedaten hinzufügen aus, um zur Seite Anmeldedaten hinzufügen zu gelangen. Wählen Sie Game Server als Anmeldedatentyp aus und fahren Sie mit dem Bereich Autorisierung fort.
   1. Wenn Ihr Game Server 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. Sie werden zur Seite OAuth-Client-ID erstellen in der Google Cloud Platform für das Projekt weitergeleitet, das Ihrem Spiel zugeordnet ist.
      3. Füllen Sie das Formular auf der Seite aus und klicken Sie auf „Erstellen“. Achten Sie darauf, dass der Anwendungstyp auf „Webanwendung“ festgelegt ist.
      4. Kehren Sie zum Abschnitt Autorisierung auf der Seite Anmeldedaten hinzufügen zurück, wählen Sie den neu erstellten OAuth-Client aus und speichern Sie die Änderungen.

Server-Authentifizierungscode abrufen

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

1. Rufen Sie PgsGamesSignInClient_requestServerSideAccess über den Client auf.
   1. Verwende die OAuth-Client-ID, die für deinen Spielserver registriert ist, und nicht die OAuth-Client-ID deiner Android-Anwendung.
   2. Optional: Wenn Ihr Gameserver Offlinezugriff (langfristiger Zugriff mit einem Aktualisierungstoken) auf Play Games Services benötigt, können Sie den Parameter force_refresh_token auf „true“ setzen.

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

   

   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, die Spieler-ID anhand der Play-Spieldienste-REST-APIs überprüft und dann für Ihr Spiel authentifiziert werden kann.

Server-Authentifizierungscode senden

Senden Sie den Server-Autorisierungscode an Ihren Backend-Server, um ihn gegen Zugriffs- und Aktualisierungstokens einzutauschen. Verwenden Sie das Zugriffstoken, um die Play Spiele-Dienste-API im Namen des Spielers aufzurufen, und speichern Sie optional das Aktualisierungstoken, um ein neues Zugriffstoken abzurufen, wenn das Zugriffstoken abläuft.

Weitere Informationen zur Funktionsweise von 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 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 Authentifizierung mit der ID und den Profildaten des Spielers durchführen? Rufen Sie Players.get mit 'me' als ID auf.

Erfolge

Weitere Informationen

• 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 Erfolg für einen Spieler 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 die Methoden Achievements.reset oder Achievements.resetAll aus den Management APIs aufrufen, um Erfolge auf ihren ursprünglichen Zustand zurückzusetzen.