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

Logowanie się w grach na Androida

Aby mieć dostęp do funkcji usług gier Google Play, musisz udostępnić swoje konto zalogowanego gracza. Jeśli odtwarzacz nie jest uwierzytelniony, podczas nawiązywania połączenia z interfejsami API usług gier Google Play mogą wystąpić błędy. Z tej dokumentacji dowiesz się, jak wdrożyć funkcję płynnego logowania się w grze.

Wdrażanie logowania się graczy

Klasa GoogleSignInClient to główny punkt wejścia, który ma być używany do pobierania konta użytkownika, na którym jesteś obecnie zalogowany, oraz do logowania się, jeśli nie zrobiono tego wcześniej w Twojej aplikacji na urządzeniu.

Aby utworzyć klienta do logowania, wykonaj te czynności:

Utwórz klienta logowania za pomocą obiektu GoogleSignInOptions, jak pokazano w poniższym fragmencie kodu. W GoogleSignInOptions.Builder musisz skonfigurować logowanie, podając GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Jeśli chcesz użyć SnapshotsClient, dodaj .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) do GoogleSignInOptions.Builder w sposób podany w tym fragmencie kodu:
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Uwaga: nie żądaj innych zakresów ani danych z profilu Google, jeśli nie są niezbędne w Twoim przypadku. Każdy inny zakres powoduje pierwsze nieudane logowanie, z wyjątkiem użytkowników, którzy zalogowali się wcześniej 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 zwraca instancję GoogleSignInClient.

Sprawdzanie, czy użytkownik jest już zalogowany

Za pomocą GoogleSignIn.getLastSignedInAccount() możesz sprawdzić, czy konto jest już zalogowane na urządzeniu i czy wymagane uprawnienia zostały już przyznane za pomocą GoogleSignIn.hasPermissions(). Jeśli oba warunki są spełnione – getLastSignedInAccount() zwraca wartość niepustą, a hasPermissions() zwraca true – możesz bezpiecznie korzystać z konta zwróconego z getLastSignedInAccount(), nawet jeśli urządzenie jest offline.

Przeprowadzanie cichego logowania

Możesz wywołać metodę silentSignIn(), by pobrać konto aktualnie zalogowanego gracza i zalogować się w nim bez wyświetlania interfejsu, jeśli zaloguje się on w Twojej aplikacji na innym urządzeniu.

Metoda silentSignIn() zwraca Task<GoogleSignInAccount>. Po ukończeniu zadania ustaw pole GoogleSignInAccount, które zostało zadeklarowane wcześniej, na konto logowania, które jest zwracane jako wynik, lub na null, co oznacza, że nie ma zalogowanego użytkownika.

Jeśli cicha próba logowania nie powiedzie się, możesz opcjonalnie wysłać intencję logowania, aby wyświetlić interfejs logowania, zgodnie z opisem w sekcji Wykonywanie interaktywnego logowania.

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

Aby zalogować się dyskretnie, wykonaj te czynności:

Aby rozpocząć cichy proces logowania, wywołaj metodę silentSignIn() na urządzeniu GoogleSignInClient. Jeśli wywołanie się powiedzie, zostanie zwrócony obiekt Task<GoogleSignInAccount> zawierający GoogleSignInAccount.
Aby zastąpić sukcesy lub niepowodzenia logowania się w odtwarzaczu, zastąp fragment OnCompleteListener.
- Jeśli udało Ci się zalogować, uzyskaj obiekt GoogleSignInAccount przez wywołanie getResult().
- Jeśli nie udało Ci się zalogować, możesz wysłać intencję logowania, aby uruchomić interaktywny proces logowania. Listę dodatkowych słuchaczy, których możesz użyć, znajdziesz w Przewodniku po interfejsie API Listy zadań i w dokumentacji Task.

Ten fragment kodu pokazuje, jak aplikacja może logować się cicho:

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 cichego logowania się nie powiedzie, możesz wywołać metodę getException(), aby uzyskać kod ApiException ze szczegółowym kodem stanu. Kod stanu CommonStatusCodes.SIGN_IN_REQUIRED wskazuje, że aby zalogować się, użytkownik musi wykonać określone działanie. W takim przypadku aplikacja powinna uruchomić interaktywny proces logowania w sposób opisany w następnej sekcji.

Wykonywanie interaktywnego logowania

Aby zalogować się za pomocą odtwarzacza, aplikacja musi uruchomić intencję logowania. Jeśli test się powiedzie, interfejs Google Sign-In API wyświetli użytkownikowi prośbę o wpisanie danych logowania. To podejście upraszcza tworzenie aplikacji, ponieważ aktywność związana z logowaniem obejmuje sytuacje, takie jak konieczność zaktualizowania Usług Google Play czy wyświetlanie prośby o zgodę w imieniu aplikacji. Wynik jest zwracany przez wywołanie zwrotne onActivityResult.

Aby zalogować się w sposób interaktywny:

Wywołaj getSigninIntent() na urządzeniu GoogleSignInClient, aby uzyskać intencję logowania, a potem 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() przetwórz wynik z zwróconej intencji.

Jeśli udało się zalogować, pobierz obiekt GoogleSignInAccount z GoogleSignInResult.
Jeśli wynik logowania nie powiódł się, musisz naprawić błąd logowania (na przykład przez wyświetlanie komunikatu o błędzie w alercie). Ten fragment kodu pokazuje, jak Twoja aplikacja może obsługiwać wyniki logowania się w odtwarzaczu:

@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

Interfejs GoogleSignInAccount zwracany przez interfejs Google Sign-In API nie zawiera żadnych informacji o graczu. Jeśli Twoja gra używa danych gracza, np. wyświetlanej nazwy i identyfikatora, możesz wykonać te czynności, aby pobrać te informacje.

Uzyskaj obiekt PlayersClient, wywołując metodę getPlayersClient() i przekazując GoogleSignInAccount jako parametr.
Aby asynchronicznie wczytać obiekt Player zawierający informacje o graczu, użyj metod PlayersClient. Możesz na przykład wywołać metodę getCurrentPlayer(), by wczytać zalogowany użytkownik. Jeśli zadanie zwraca ApiException z kodem stanu SIGN_IN_REQUIRED, oznacza to, że odtwarzacz musi zostać ponownie uwierzytelniony. Aby to zrobić, wywołaj funkcję GoogleSignInClient.getSignInIntent(), aby zalogować się w odtwarzaczu interaktywnym.
Jeśli zadanie zwróci obiekt Player, możesz wywołać metody obiektu Player, aby pobrać określone informacje o odtwarzaczu (na przykład getDisplayName() lub getPlayerId()).

Udostępnienie przycisku logowania

Aby udostępnić w grze standardowy przycisk logowania Google, możesz użyć jednej z tych metod:

Umieść com.google.android.gms.common.SignInButton w głównym układzie aktywności lub
Zaprojektuj niestandardowy przycisk logowania zgodny ze wskazówkami dotyczącymi promowania marki przez Google.

Gdy użytkownik kliknie przycisk logowania, gra powinna rozpocząć proces logowania, wysyłając intencję logowania zgodnie z opisem w sekcji Wykonywanie interaktywnego logowania.

Ten fragment kodu pokazuje, jak dodać przycisk logowania do metody onCreate() dla Twojej 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);
}

Fragment kodu poniżej 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świetlanie wyskakujących okienek z gier

Wyskakujące okienka w grze możesz wyświetlać za pomocą klasy GamesClient. Na przykład w grze może pojawić się wyskakujące okienko „Witamy ponownie” lub „Osiągnięcia odblokowane”. Aby umożliwić usługom gier Google Play wyświetlanie wyskakujących okienek w grze, wywołaj metodę setViewForPopups(). Możesz jeszcze bardziej dostosować miejsce, w którym wyświetla się wyskakujące okienko, wywołując opcję setGravityForPopups().

Wylogowywanie gracza

Aby się wylogować, wywołaj metodę signOut() na urządzeniu 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.
        }
      });
}