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

Logowanie się w grach na Androida

W związku z wycofaniem interfejsu Logowania przez Google w 2026 r. usuniemy pakiet SDK gier w wersji 1. Po lutym 2025 r. nie będzie można publikować w Google Play tytułów, które zostały dopiero zintegrowane z pakietem SDK gier w wersji 1. Zalecamy zamiast tego korzystać z pakietu SDK gier w wersji 2.
Chociaż istniejące tytuły z integracją poprzedniej wersji gry 1 będą działać przez kilka lat, zachęcamy do przejścia na wersję 2 od czerwca 2025 r.
Ten przewodnik dotyczy pakietu SDK usług gier Play w wersji 1. Informacje o najnowszej wersji pakietu SDK znajdziesz w dokumentacji wersji 2.

Aby korzystać z funkcji Usług Gier Google Play, gra musi udostępnić konto zalogowanego gracza. Jeśli gracz nie jest uwierzytelniony, podczas wywoływania interfejsów API usług Google Play Games w grze mogą wystąpić błędy. Z tej dokumentacji dowiesz się, jak wdrożyć w swojej grze płynne logowanie.

Wdrażanie logowania przez gracza

Klasa GoogleSignInClient jest głównym punktem wejścia do pobierania konta aktualnie zalogowanego gracza i logowania gracza, jeśli nie zrobił tego wcześniej w aplikacji na urządzeniu.

Aby utworzyć klienta logowania:

Utwórz klienta logowania za pomocą obiektu GoogleSignInOptions, jak pokazano w tym fragmencie kodu. Aby skonfigurować logowanie, musisz w ustawieniach GoogleSignInOptions.Builder podać informacje o GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Jeśli chcesz użyć tagu SnapshotsClient, dodaj do niego tag .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS), jak pokazano w tym fragmencie kodu:GoogleSignInOptions.Builder
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Uwaga: nie proś o żadne inne zakresy ani dane profilu Google, chyba że są one niezbędne do Twojego przypadku użycia. W przypadku innych zakresów logowanie bez hasła po raz pierwszy nie powiedzie się, z wyjątkiem użytkowników, którzy już się zalogowali na innym urządzeniu.
Wywołaj metodę GoogleSignIn.getClient() i przekaż opcje skonfigurowane w poprzednich krokach. Jeśli wywołanie się powiedzie, interfejs Google Sign-In API zwróci wystąpienie obiektu GoogleSignInClient.

Sprawdzanie, czy odtwarzacz jest już zalogowany

Możesz sprawdzić, czy konto jest już zalogowane na bieżącym urządzeniu za pomocą GoogleSignIn.getLastSignedInAccount()i czy to konto ma już wymagane uprawnienia przyznane za pomocą GoogleSignIn.hasPermissions(). Jeśli oba warunki są spełnione (czyli funkcja getLastSignedInAccount() zwraca wartość inną niż null, a funkcja hasPermissions() zwraca wartość true), możesz bezpiecznie korzystać z konta zwracanego przez funkcję getLastSignedInAccount(), nawet jeśli urządzenie jest offline.

Możesz wywołać funkcję silentSignIn(), aby pobrać konto aktualnie zalogowanego gracza, i spróbować zalogować graczy bez wyświetlania interfejsu użytkownika, jeśli zalogowali się już w Twojej aplikacji na innym urządzeniu.

Metoda silentSignIn() zwraca Task<GoogleSignInAccount>. Po zakończeniu zadania deklarowane wcześniej pole GoogleSignInAccount ustawiasz na zalogowane konto, które zadanie zwraca jako wynik, lub na null, co oznacza, że nie ma zalogowanego użytkownika.

Jeśli próba cichego logowania się zakończy się niepowodzeniem, możesz opcjonalnie wysłać zamiar logowania, aby wyświetlić interfejs logowania, zgodnie z opisem w artykule Interaktywne logowanie.

Stan zalogowanego gracza może się zmienić, gdy aktywność nie jest na pierwszym planie. Dlatego zalecamy wywołanie metody silentSignIn() z metody onResume() aktywności.

Aby zalogować się bez dźwięku, wykonaj te czynności:

Aby rozpocząć procedurę cichego logowania, wywołaj metodę silentSignIn() w GoogleSignInClient. To wywołanie zwraca obiekt Task<GoogleSignInAccount>, który zawiera element GoogleSignInAccount, jeśli logowanie bez potwierdzenia się powiedzie.
Za pomocą funkcji zastąpienia OnCompleteListener możesz określić, czy logowanie się gracza zakończyło się powodzeniem.
- Jeśli zadanie logowania się zakończyło się powodzeniem, pobierz obiekt GoogleSignInAccount, wywołując metodę getResult().
- Jeśli nie udało się zalogować, możesz wysłać intencję logowania, aby uruchomić interaktywny proces logowania. Listę dodatkowych odbiorców wywołań zwrotnych, których możesz używać, znajdziesz w przewodniku dla deweloperów interfejsu Tasks API i Task w części Przewodnik po interfejsie API.

Ten fragment kodu pokazuje, jak aplikacja może wykonać cichą procedurę logowania:

private void signInSilently() {
  GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
  GoogleSignInAccount account = GoogleSignIn.getLastSignedInAccount(this);
  if (GoogleSignIn.hasPermissions(account, signInOptions.getScopeArray())) {
    // Already signed in.
    // The signed in account is stored in the 'account' variable.
    GoogleSignInAccount signedInAccount = account;
  } else {
    // Haven't been signed-in before. Try the silent sign-in first.
    GoogleSignInClient signInClient = GoogleSignIn.getClient(this, signInOptions);
    signInClient
        .silentSignIn()
        .addOnCompleteListener(
            this,
            new OnCompleteListener<GoogleSignInAccount>() {
              @Override
              public void onComplete(@NonNull Task<GoogleSignInAccount> task) {
                if (task.isSuccessful()) {
                  // The signed in account is stored in the task's result.
                  GoogleSignInAccount signedInAccount = task.getResult();
                } else {
                  // Player will need to sign-in explicitly using via UI.
                  // See [sign-in best practices](http://developers.google.com/games/services/checklist) for guidance on how and when to implement Interactive Sign-in,
                  // and [Performing Interactive Sign-in](http://developers.google.com/games/services/android/signin#performing_interactive_sign-in) for details on how to implement
                  // Interactive Sign-in.
                }
              }
            });
  }
}

@Override
protected void onResume() {
  super.onResume();
  signInSilently();
}

Jeśli próba bezgłośnego logowania się nie powiedzie się, możesz zadzwonić pod numer getException(), aby uzyskać ApiExceptionz kodem stanu szczegółowego. Kod stanu CommonStatusCodes.SIGN_IN_REQUIRED wskazuje, że gracz musi wykonać określone działanie, aby się zalogować. W takim przypadku aplikacja powinna uruchomić interaktywny proces logowania, jak opisano w następnej sekcji.

Aby umożliwić logowanie się po interakcji z graczem, aplikacja musi uruchomić odpowiednią intencję. W przypadku powodzenia interfejs Google Sign-In API wyświetla użytkownikowi prośbę o wpisanie danych logowania. Takie podejście upraszcza tworzenie aplikacji, ponieważ aktywność logowania umożliwia obsługę takich scenariuszy jak konieczność aktualizacji usług Google Play lub wyświetlanie prośby o zgodę w imieniu aplikacji. Wynik jest zwracany przez funkcję onActivityResult.

Aby zalogować się w interaktywny sposób:

Wywołaj getSigninIntent() na karcie GoogleSignInClient, aby uzyskać intencję logowania, a następnie wywołaj startActivity() i przekaż tę intencję. Ten fragment kodu pokazuje, jak aplikacja może uruchomić interaktywny proces logowania:

private void startSignInIntent() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}

W wywołaniu zwrotnym onActivityResult() obsłuż wynik zwróconego zamiaru.

Jeśli logowanie się zakończyło sukcesem, pobierz obiekt GoogleSignInAccount z elementu GoogleSignInResult.
Jeśli logowanie się nie powiedzie, musisz obsłużyć błąd logowania (np. wyświetlając komunikat o błędzie w powiadomieniu). Ten fragment kodu pokazuje, jak aplikacja może obsługiwać wyniki logowania gracza:

@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()) {
      // The signed in account is stored in the result.
      GoogleSignInAccount signedInAccount = result.getSignInAccount();
    } 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();
    }
  }
}

Pobieranie informacji o odtwarzaczu

Parametr GoogleSignInAccount zwracany przez interfejs Google Sign-in API nie zawiera żadnych informacji o graczach. Jeśli Twoja gra korzysta z informacji o graczu, takich jak jego wyświetlana nazwa i identyfikator, możesz je pobrać, wykonując te czynności.

Uzyskaj obiekt PlayersClient, wywołując metodę getPlayersClient() i przekazując jako parametr GoogleSignInAccount.
Użyj metod PlayersClient, aby asynchronicznie wczytać obiekt Playerz informacjami o graczu. Możesz na przykład wywołać funkcję getCurrentPlayer(), aby załadować odtwarzacz dla aktualnie zalogowanego użytkownika. Jeśli zadanie zwróci odpowiedź ApiException z kodem stanu SIGN_IN_REQUIRED, oznacza to, że trzeba ponownie uwierzytelnić odtwarzacz. Aby to zrobić, zadzwoń pod numer GoogleSignInClient.getSignInIntent(), aby zalogować odtwarzacz w interaktywny sposób.
Jeśli zadanie zwróci obiekt Player, możesz wywołać metody obiektu Player, aby pobrać określone dane gracza (np. getDisplayName() lub getPlayerId()).

Aby w grze udostępnić standardowy przycisk logowania w Google, możesz użyć jednego z tych rozwiązań:

Uwzględnij element com.google.android.gms.common.SignInButton w układzie głównej aktywności;
Zaprojektuj niestandardowy przycisk logowania zgodnie ze wskazówkami dotyczącymi marki logowania Google.

Gdy użytkownicy klikną przycisk logowania, gra powinna zainicjować proces logowania, wysyłając odpowiednią prośbę, zgodnie z opisem w artykule Interaktywna procedura logowania.

Ten fragment kodu pokazuje, jak dodać przycisk logowania w metodzie onCreate() aktywności.

@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_sign_in);
  findViewById(R.id.sign_in_button).setOnClickListener(this);
  findViewById(R.id.sign_out_button).setOnClickListener(this);
}

Ten fragment kodu pokazuje, jak wysłać intencję logowania, gdy użytkownik kliknie przycisk logowania.

@Override
public void onClick(View view) {
  if (view.getId() == R.id.sign_in_button) {
    // start the asynchronous sign in flow
    startSignInIntent();
  } else if (view.getId() == R.id.sign_out_button) {
    // sign out.
    signOut();
    // show sign-in button, hide the sign-out button
    findViewById(R.id.sign_in_button).setVisibility(View.VISIBLE);
    findViewById(R.id.sign_out_button).setVisibility(View.GONE);
  }
}

wyświetlać wyskakujące okienka z grami;

Możesz wyświetlać w grze widoki wyskakujące, korzystając z klasy GamesClient. Na przykład gra może wyświetlić okienko „Witaj z powrotem” lub „Osiągnięcia odblokowane”. Aby umożliwić Usługom gier Google Play uruchamianie wyskakujących okienek w widokach w grze, wywołaj metodę setViewForPopups(). Możesz dostosować, gdzie wyskakujące okienko ma się wyświetlać na ekranie, wywołując funkcję setGravityForPopups().

Wyloguj gracza

Wylogowanie odbywa się przez wywołanie metody signOut() na obiekcie GoogleSignInClient.

private void signOut() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  signInClient.signOut().addOnCompleteListener(this,
      new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
          // at this point, the user is signed out.
        }
      });
}