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

Logowanie się w grach na Androida

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 to główny punkt wejścia do pobierania danych z konta aktualnie zalogowanego gracza oraz logowania go, 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 zastosowania. W przypadku innych zakresów logowanie w trybie cichym nie powiedzie się po raz pierwszy, 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 Logowanie przez Google 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 przypisane 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 używać 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 wartość 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 zakończyło się sukcesem.
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 wywołań zwrotnych, których możesz używać, znajdziesz w przewodniku po interfejsie 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 zalogowania się się nie powiedzie, 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świetli komunikat z prośbą o podanie 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.
Aby asynchronicznie wczytać obiekt Player zawierający informacje o graczu, użyj metod PlayersClient. 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 odtwarzacz musi zostać ponownie uwierzytelniony. Aby to zrobić, wybierz 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 zamiar logowania zgodnie z opisem w artykule Interaktywne logowanie.

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 „Witamy ponownie” 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ć lokalizację wyskakującego okienka 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.
        }
      });
}