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, wykonaj te czynności:

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, Google Sign-In API zwróci instancję 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 getLastSignedInAccount() zwraca wartość niepustą, a hasPermissions() zwraca true, możesz bezpiecznie używać konta zwróconego przez getLastSignedInAccount(), nawet gdy 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:

Wywołaj metodę silentSignIn() w GoogleSignInClient, aby rozpocząć proces dyskretnego logowania. Jeśli logowanie w trybie cichym się powiedzie, to wywołanie zwróci obiekt Task<GoogleSignInAccount>, który zawiera symbol GoogleSignInAccount.
Aby rozwiązać problem udanego lub nieudanego logowania się przez odtwarzacz, zastąp OnCompleteListener.
- 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 detektorów wywołań zwrotnych, których możesz użyć, znajdziesz w przewodniku dla programistów po interfejsie Tasks API i w dokumentacji interfejsu API Task.

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 oznacza, że gracz musi wykonać wyraźne działanie, by się zalogować. W takim przypadku aplikacja powinna uruchomić interaktywny proces logowania, jak opisano w następnej sekcji.

Aby można było logować się z użyciem interakcji z graczem, aplikacja musi uruchomić intencję logowania. 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ść związana z logowaniem uwzględnia takie sytuacje, jak konieczność zaktualizowania Usług Google Play lub wyświetlanie próśb o zgodę na wykorzystanie danych 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 w aplikacji możesz 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 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 graczu

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 Player zawierający informacje o odtwarzaczu. 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ć, wywołaj GoogleSignInClient.getSignInIntent(), by zalogować się w odtwarzaczu w sposób interaktywny.
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żytkownik kliknie przycisk logowania, gra powinna zainicjować proces logowania, wysyłając intencję logowania, jak opisano to w sekcji Wykonywanie interaktywnego 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świetl wyskakujące okienka gier

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