Ta strona została przetłumaczona przez Cloud Translation API.

Włączanie dostępu po stronie serwera do usług gier Google Play

Zalecamy uwierzytelnianie graczy i bezpiecznie przekazać tożsamość gracza do serwera zaplecza. Dzięki temu aby bezpiecznie pobierać tożsamość gracza i inne dane bez na potencjalne ingerencje w urządzenie.

W tym scenariuszu, gdy loguje się, możesz poprosić o specjalny jednorazowy kod (nazywanym kodem autoryzacji serwera) z pakietu SDK usług gier Play w wersji 2, który klient przekazuje na serwer. Następnie na serwerze kod uwierzytelniania serwera OAuth 2.0, którego serwer może używać do wywoływania Interfejs API usług gier Google Play.

Dodatkowe wskazówki dotyczące dodawania metod logowania w grach znajdziesz w artykule Logowanie się w Grach na Androida

Aby uzyskać dostęp w trybie offline, musisz wykonać te czynności:

W Konsoli Google Play: utwórz dane logowania do serwera gier. Typ klienta OAuth danych logowania to „internet”.
W aplikacji na Androida: podczas logowania poproś o kod autoryzacji serwera dla swojego dane logowania serwera i przekazać je do serwera.
Na serwerze gry: wymieniaj kod autoryzacji serwera na potrzeby dostępu OAuth za pomocą usług uwierzytelniania Google, a następnie użyj go do wywołania metody Interfejsy API typu REST usług gier Play.

Zanim zaczniesz

Najpierw musisz dodać grę do Konsoli Google Play, jak opisano na stronie Skonfiguruj usługi gier Google Play i zintegruj ze swoją grą funkcję logowania w usługach gier Play.

Utwórz powiązaną z grą aplikację internetową po stronie serwera

Usługi gier Google Play nie zapewniają backendu i obsługuje gry internetowe. Zapewnia jednak obsługę serwerów backendu na serwer gry na Androida.

Jeśli chcesz użyć atrybutu Interfejsy API typu REST dla usług gier Google Play w aplikacji po stronie serwera, wykonaj te czynności:

W grze w Konsoli Google Play kliknij Usługi gier Play > Konfiguracja i zarządzanie > Konfiguracja.
Wybierz Dodaj dane logowania, aby otworzyć stronę Dodaj dane logowania. Jako typ danych logowania wybierz Serwer gry i przejdź do sekcji Autoryzacja.
1. Jeśli serwer gry ma już identyfikator klienta OAuth, wybierz go z menu. Po zapisaniu zmian przejdź do następnej sekcji.
2. Jeśli nie masz identyfikatora klienta OAuth serwera gry, możesz go utworzyć.
  1. Kliknij Utwórz klienta OAuth i kliknij link Utwórz identyfikator klienta OAuth.
  2. Spowoduje to otwarcie strony Utwórz identyfikator klienta OAuth w Google Cloud Platform dla projektu Cloud Platform powiązanego z grą.
  3. Wypełnij formularz na stronie i kliknij Utwórz. Pamiętaj, aby ustawić typ aplikacji na Aplikacja internetowa.
  4. Wróć do sekcji Autoryzacja na stronie dodawania danych logowania, wybierz nowo utworzonego klienta OAuth i zapisz zmiany.

Uzyskiwanie kodu autoryzacji serwera

Aby pobrać kod uwierzytelniania serwera, którego gra może używać do uzyskiwania tokenów dostępu na serwerze backendu:

Wywołaj połączenie requestServerSideAccess z poziomu klienta.

Upewnij się, że używasz identyfikatora klienta OAuth zarejestrowanego na serwerze gier, a nie identyfikatora klienta OAuth aplikacji na Androida.
(Opcjonalnie) Jeśli serwer gier wymaga dostępu offline (długotrwałego dostępu przy użyciu tokena odświeżania) do usług gier Play, możesz ustawić wartość parametru forceRefreshToken na wartość „true”.

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

Wyślij token kodu uwierzytelniania OAuth do serwera backendu, aby go wymienić, identyfikator gracza zweryfikowany w interfejsach API REST usług gier Play, a następnie uwierzytelnienie w grze.

Wymiana kodu uwierzytelniania serwera na token dostępu na serwerze

Wyślij kod uwierzytelniania serwera do serwera backendu, aby wymienić go na tokeny dostępu i odświeżyć. Użyj tokena dostępu, aby wywołać interfejs Google Play Games Services API w imieniu gracza i opcjonalnie przechowywać token odświeżania, aby uzyskać nowy token dostępu po jego wygaśnięciu.

Poniższy fragment kodu pokazuje, jak możesz zaimplementować kod po stronie serwera w Javie za pomocą języka programowania i wymiany kodu uwierzytelniania serwera na tokeny dostępu. Jest za pomocą clientserverskeleton – przykładowa aplikacja:

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

Wywoływanie interfejsów API typu REST z serwera

Zapoznaj się z interfejsami API typu REST dla usług Gier Google Play, aby dowiedzieć się więcej. pełny opis dostępnych wywołań interfejsu API.

Przykłady wywołań interfejsu API REST, które mogą Ci się przydać:

Zawodnik

Chcesz pobrać identyfikator i dane profilu zalogowanego gracza? Zadzwoń do Players.get z identyfikatorem 'me'.

Znajomi

Zapoznaj się z przewodnikiem Znajomi, który zawiera więcej informacji o znajomych.

Chcesz pobrać listę znajomych gracza? Zadzwoń na stronę Players.list, używając kodu 'friends_all' jako collection.
Sprawdź, czy masz dostęp do listy znajomych? Wywołaj Players.get za me, a spójrz na pole profileSettings.friendsListVisibility w odpowiedzi.

Osiągnięcia

Zapoznaj się z przewodnikiem Osiągnięcia, w którym opisujemy osiągnięcia. .

Chcesz zobaczyć listę aktualnych osiągnięć? Możesz wywołać stronę AchievementDefinitions.list.
Możesz to też połączyć z wywołaniem strony Achievements.list, aby dowiedzieć się, które z nich odblokował gracz.
Czy gracz zdobył osiągnięcie? Aby go odblokować, użyj platformy Achievements.unlock.
Czy gracz osiągnął częściowe osiągnięcie? Użyj rozszerzenia Achievements.increment, aby: zgłaszać postępy (i sprawdzić, czy gracz odblokował blok).
Czy debugujesz grę, która nie jest jeszcze w wersji produkcyjnej? Spróbuj zadzwonić Achievements.reset lub Achievements.resetAll w interfejsach API zarządzania. , by przywrócić osiągnięcia do ich pierwotnego stanu.

Tabele wyników

Zapoznaj się z przewodnikiem Tablice wyników, który zawiera więcej informacji.

Chcesz zobaczyć listę wszystkich tablic wyników w grze? Wezwij stronę Leaderboards.list.
Czy gracz kończy grę? Możesz przesłać ich wynik na Scores.submit, aby dowiedzieć się, czy to nowy rekord.
Chcesz wyświetlić tabelę wyników? Pobierz dane z witryny Scores.list i wyświetl je użytkownikowi.
Użyj narzędzia Scores.listWindow, aby znaleźć zbiór wyników bliskich rekordów użytkownika.
Aby uzyskać więcej informacji o wyniku gracza w określonej tabeli wyników (na przykład, jeśli należy do 12% najlepszych graczy), wywołaj Scores.get.
Debugujesz grę? Spróbuj wywołać Scores.reset z poziomu zarządzania interfejsy API do resetowania wszystkich wyników danego gracza z określonej tabeli wyników.