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, gra musi mieć: na koncie zalogowanego gracza. Jeśli gracz nie jest uwierzytelniony, w grze mogą wystąpić błędy przy wysyłaniu wywołań do interfejsów API usług gier Google Play. W tej dokumentacji dowiesz się, jak wdrożyć w swojej grze bezproblemowe logowanie.

Wdrażanie logowania odtwarzacza

Klasa GoogleSignInClient jest głównym punktem wejścia, za pomocą którego pobiera się zalogowany odtwarzacz, a także zalogować się, jeśli jeszcze tego nie zrobił w Twojej aplikacji, urządzenia.

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

Utwórz klienta logowania w GoogleSignInOptions Jak widać w poniższym fragmencie kodu. W GoogleSignInOptions.Builder aby skonfigurować logowanie, musisz podać GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Jeśli chcesz użyć rozszerzenia SnapshotsClient następnie dodaj .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) do GoogleSignInOptions.Builder Jak widać w tym fragmencie kodu:
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Uwaga: nie żądaj żadnych innych zakresów ani danych z profilu Google, chyba że są kluczowe w Twoim przypadku użycia. Każdy inny zakres powoduje pierwszy raz ciche logowanie, które kończy się niepowodzeniem, z wyjątkiem użytkowników, którzy już się zalogowali na innym urządzeniu.
Wywołaj metodę GoogleSignIn.getClient() i przekaż ją korzystając z opcji skonfigurowanych w poprzednich krokach. Jeśli połączenie jest Google Sign-In API zwróci instancję GoogleSignInClient

Sprawdzanie, czy gracz jest już zalogowany

Możesz sprawdzić, czy jesteś już zalogowany na konto na bieżącym urządzeniu za pomocą GoogleSignIn.getLastSignedInAccount() oraz sprawdzić, czy to konto ma już wymagane uprawnienia przyznane za pomocą GoogleSignIn.hasPermissions() Jeśli oba warunki są spełnione, czyli getLastSignedInAccount() zwraca błąd nie jest null, a hasPermissions() zwraca true. Możesz bezpiecznie użyć funkcji z konta getLastSignedInAccount(), nawet jeśli urządzenie jest offline.

Przeprowadzam logowanie w trybie cichym

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

Metoda silentSignIn() zwraca Task<GoogleSignInAccount>. Gdy zadanie się zakończy, ustawisz zadeklarowane wcześniej pole GoogleSignInAccount na konto logowania, które ma zwraca jako wynik lub do null, co oznacza, że użytkownik nie jest zalogowany.

Jeśli dyskretna próba logowania się nie powiedzie, możesz opcjonalnie wysłać intencję logowania, aby wyświetlić komunikat interfejsu logowania się, jak opisano w Logowanie interaktywne

Stan zalogowanego gracza może się zmienić, jeśli aktywność nie działa na pierwszym planie, zalecana rozmowa (silentSignIn()) z poziomu aktywności onResume() .

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

Wywołaj metodę silentSignIn() w GoogleSignInClient, aby rozpocząć proces dyskretnego logowania. To wywołanie zwraca obiekt Task<GoogleSignInAccount> zawierający GoogleSignInAccount, jeśli dyskretne logowanie.
Zastąp udane lub nieudane logowanie odtwarzaczy. OnCompleteListener
- Jeśli logowanie się udało, pobierz GoogleSignInAccount przez wywołanie getResult().
- Jeśli logowanie się nie udało, 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 Przewodnik dla programistów po interfejsie Tasks API i Task Dokumentacja API.

Ten fragment kodu pokazuje, jak w aplikacji można logować się dyskretnie:

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 dyskretna próba logowania się nie powiedzie, możesz zadzwonić getException() do uzyskaj ApiException ze szczegółowym kodem stanu. kod stanu CommonStatusCodes.SIGN_IN_REQUIRED, oznacza, że użytkownik musi wykonać wyraźne działanie, aby się zalogować. W takim przypadku aplikacja powinna i uruchomić interaktywny proces logowania się, jak opisano w następnej sekcji.

Logowanie interaktywne

Aby można było logować się z użyciem interakcji z graczem, aplikacja musi uruchomić intencję logowania. Jeśli operacja się uda, interfejs Google Sign-In API wyświetla interfejs, w którym odtwarzacz prosi o wpisanie danych logowania; aby się zalogować. Upraszcza to tworzenie aplikacji, ponieważ działania związane z logowaniem w sytuacjach takich jak konieczność zaktualizowania Usług Google Play lub wyświetlania próśb o zgodę w imieniu Google. Wynik jest zwracany przez metodę onActivityResult oddzwanianie.

Aby zalogować się w sposób interaktywny:

Zadzwoń pod numer getSigninIntent() na GoogleSignInClient, aby uzyskać zamiar logowania, a następnie wywołaj startActivity() i przekazać tę intencję. Ten fragment kodu pokazuje, jak aplikacja może i 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: onActivityResult() wywołanie zwrotne, obsługuje wynik zwróconej intencji.

Jeśli logowanie przebiegło pomyślnie, sprawdź GoogleSignInAccount obiekt z GoogleSignInResult.
Jeśli nie udało Ci się zalogować, rozwiąż problem z logowaniem (na przykład 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 graczu

Element GoogleSignInAccount zwracany przez interfejs Google Sign-In API nie zawiera żadnego odtwarzacza i informacjami o nich. Jeśli Twoja gra korzysta z informacji o graczu, takich jak jego wyświetlana nazwa i identyfikator: możesz wykonać poniższe czynności, aby odzyskać te informacje.

Uzyskaj obiekt PlayersClient, wywołując metodę getPlayersClient() i przekazując GoogleSignInAccount jako parametr.
Użyj metod PlayersClient, aby asynchronicznie wczytywać komponent Player , który zawiera informacje o graczu. Możesz na przykład zadzwonić pod numer getCurrentPlayer() w celu wczytania aktualnie zalogowanego odtwarzacza. Jeśli zadanie zwraca błąd ApiException z kodem stanu z SIGN_IN_REQUIRED, oznacza to, że odtwarzacz wymaga ponownego uwierzytelnienia. W tym celu wywołaj GoogleSignInClient.getSignInIntent() do interaktywnego logowania się w odtwarzaczu.
Jeśli zadanie zwróci obiekt Player, możesz wywołać metody klasy Player, aby pobrać szczegółowe informacje o odtwarzaczu (na przykład getDisplayName() lub getPlayerId().

Udostępnianie przycisku logowania

Aby udostępnić w grze standardowy przycisk logowania przez Google, możesz użyć jednej z podejścia:

Dodaj com.google.android.gms.common.SignInButton w głównym układzie działań; lub
Zaprojektuj niestandardowy przycisk logowania zgodny z marką Logowania przez Google wytycznych.

Gdy użytkownik kliknie przycisk logowania, gra powinna rozpocząć proces logowania, wysyłając wiadomość intencję logowania, jak opisano w sekcji Wykonywanie logowania interaktywnego.

Ten fragment kodu pokazuje, jak dodać przycisk logowania w narzędziu onCreate(). do 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świetlam wyskakujące okienka z grami

Widoki wyskakujących okienek w grze możesz wyświetlić za pomocą klasy GamesClient. Na przykład Twoja gra może wyświetlić się wyskakujące okienko „Witamy ponownie” lub „Osiągnięcia odblokowane”. Aby zezwolić na Usługi gier Google Play , aby uruchomić wyskakujące okienka w widokach gry, wywołaj setViewForPopups() . Możesz dodatkowo dostosować miejsce wyświetlania wyskakującego okienka na ekranie, dzwoniąc setGravityForPopups()

Wylogowywanie gracza

Wylogowanie się odbywa się przez wywołanie metody signOut() na 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.
        }
      });
}