Serverseitigen Zugriff auf Google Play-Spieldienste aktivieren

Wenn dein Spiel einen Backend-Server verwendet, empfehlen wir die Verwendung von Google Log-in zum Authentifizieren von Spielern und die Identität des Spielers sicher an den Back-End-Server weiterzugeben. Dies ermöglicht auch um die Identität und andere Daten des Spielers sicher abzurufen, während das Gerät möglicherweise manipuliert wird.

In diesem Szenario wird der Spieler vom Spiel aufgefordert, sich wie gewohnt in den Google Play-Spieldiensten anzumelden. Wenn der Parameter Spieler sich erfolgreich angemeldet hat, enthält das GoogleSignInAccount-Objekt einen speziellen Einmalcode (auch Serverauthentifizierungscode genannt), den 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

Ein detailliertes Codebeispiel zur Authentifizierung von Spielern mit Google Log-in finden Sie auf der clientserverskeleton-Beispiel auf GitHub.

Für den Offlinezugriff sind die folgenden Schritte erforderlich:

  1. In der Google Play Console: Erstelle Anmeldedaten für deinen Gameserver. Die OAuth-Clienttyp der Anmeldedaten ist „Web“.
  2. Fordern Sie in der Android-App bei der Anmeldung einen Serverauthentifizierungscode für Ihr und geben sie an Ihren Server weiter.
  3. 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

Bevor du Google Log-in in dein Spiel integrieren kannst, musst du dein Spiel zuerst im Google Play Console, wie unter Google Play-Spieldienste einrichten

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:

  1. Erstelle eine verknüpfte Web-App für dein Spiel im Abschnitt Verknüpfte Apps von in der Google Play Console. Beachten Sie, dass 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: <ph type="x-smartling-placeholder">
      </ph>
    1. Klicken Sie in der Google Play Console auf Details zum Spiel.
    2. Scrollen Sie nach unten zum Abschnitt API Console Project (API-Konsolenprojekt) und klicken Sie auf den Link. mit dem API-Konsolenprojekt.
    3. Über die Seite APIs und Dienste > Anmeldedaten in der Google API Console die Datei client_secret.json für deine Web-App herunterladen und speichern Sie sie an einem Ort, auf den Ihr Server zugreifen kann. Client aufzeichnen ID des Berechtigungsnachweises zur späteren Verwendung.
  3. Starten Sie die serverseitige App neu, damit sie Anfragen von Ihrer die Client-App des Spiels.

Anmeldung auf dem Client ausführen

Die Klasse GoogleSignInClient ist der Haupteinstiegspunkt zum Abrufen des Kontos des aktuellen angemeldeten Player und melden sich im Player an, falls noch nicht geschehen. .

So erstellen Sie einen Anmeldeclient:

  1. Erstellen Sie über das Objekt GoogleSignInOptions einen Anmeldeclient. Im GoogleSignInOptions.Builder, um Ihre Anmeldung zu konfigurieren, müssen Sie Folgendes angeben: GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
  2. Du musst auch angeben, dass für dein Spiel eine Authentifizierung erforderlich ist für Ihren Back-End-Server durch Aufrufen der Methode Methode GoogleSignInOptions.Builder.requestServerAuthCode() mit der Client-ID des Servers als . Den Autorisierungscode für Zugriffstokens auf deinem Backend-Server wirst du später wie beschrieben abrufen in Server-Auth-Code abrufen.
  3. Rufen Sie die Methode GoogleSignIn.getClient() auf und übergeben Sie die zuvor konfigurierten Optionen. Wenn der Anruf erfolgreich war, gibt die Google Log-in API eine Instanz von GoogleSignInClient zurück.
  4. Sobald Sie die GoogleSignInClient-Instanz erhalten haben, sollten Sie mit der Anmeldung des Spielers fortfahren. lautlos über die onResume() der Aktivität, wie in Anmeldung im Hintergrund:

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

So rufen Sie einen Server-Authentifizierungscode ab, den Ihr Spiel für Zugriffstokens auf Ihrem Backend-Server verwenden kann: getServerAuthCode() aufrufen für den GoogleSignInAccount Objekt, das Google Log-in bei erfolgreicher Spieleranmeldung zurückgibt.

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

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

Weitere Informationen zum Zugriff auf Google APIs über einen Backend-Server im Namen eines angemeldeten Spielers Siehe Serverseitigen Zugriff aktivieren.

Umgang mit der Spielerabmeldung

Wenn Sie Spieler von Ihrem Spiel abmelden möchten, rufen Sie die Methode signOut() in der GoogleSignInClient auf. Für eine Beispiel für ein Code-Snippet, siehe Player abmelden:

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.

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