Diese Seite wurde von der Cloud Translation API übersetzt.

In Android-Spielen anmelden

Damit du auf die Funktionen der Google Play-Spieldienste zugreifen kannst, muss dein Spiel die Konto angemeldeter Spieler. Wenn der Spieler nicht authentifiziert ist, treten möglicherweise Fehler in Ihrem Spiel auf beim Aufrufen der APIs der Google Play-Spieldienste. In dieser Dokumentation wird beschrieben, wie Sie eine nahtlose Anmeldung in deinem Spiel zu implementieren.

Spieleranmeldung implementieren

Die Klasse GoogleSignInClient ist der Haupteinstiegspunkt zum Abrufen des Kontos des aktuellen angemeldeten Player und melden sich im Player an, falls noch nicht geschehen. .

So erstellen Sie einen Anmeldeclient:

Erstellen Sie einen Anmeldeclient über die GoogleSignInOptions enthalten, wie im folgenden Code-Snippet dargestellt. Im GoogleSignInOptions.Builder um Ihre Anmeldung zu konfigurieren, müssen Sie GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Wenn Sie eine SnapshotsClient, Dann füge .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) zu deinem GoogleSignInOptions.Builder Dies wird im folgenden Code-Snippet gezeigt:
```
GoogleSignInOptions  signInOptions =
    new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN)
        .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS)
        .build();
```
Achtung :Fordern Sie keine anderen Umfänge oder Google-Profildaten an, es sei denn, die für Ihren Anwendungsfall wichtig sind. Beliebige andere Umfangsursachen, Fehler bei der stillen Anmeldung, außer für Nutzer, die sich bereits angemeldet haben erfolgreich auf einem anderen Gerät.
Rufen Sie die Methode GoogleSignIn.getClient() auf und übergeben Sie die Sie in den vorherigen Schritten konfiguriert haben. Wenn der Anruf erfolgreich war, gibt die Google Log-in API eine Instanz GoogleSignInClient

Prüfen, ob ein Spieler bereits angemeldet ist

Sie können prüfen, ob ein Konto bereits angemeldet ist auf dem aktuellen Gerät mit GoogleSignIn.getLastSignedInAccount() und ob dieses Konto bereits über die erforderlichen Berechtigungen verfügt, GoogleSignIn.hasPermissions() Wenn beide Bedingungen erfüllt sind, d. h. getLastSignedInAccount() gibt den Fehlerwert ungleich null zurück und hasPermissions() gibt true zurück. Sie können das von getLastSignedInAccount() zurückgegebene Konto, auch wenn das Gerät offline.

Stumme Anmeldung wird durchgeführt

Du kannst silentSignIn() aufrufen, um das Konto des aktuell angemeldeten Spielers abzurufen. und versuchen, Spieler anzumelden, ohne eine Benutzeroberfläche anzuzeigen, Sie sich auf einem anderen Gerät in Ihrer App angemeldet haben.

Die Methode silentSignIn() gibt Task<GoogleSignInAccount> zurück. Wenn die Aufgabe abgeschlossen ist, Sie das zuvor deklarierte Feld GoogleSignInAccount auf das von der Aufgabe als Ergebnis zurückgegeben, oder an null, was darauf hinweist, dass kein angemeldeter Nutzer vorhanden ist.

Wenn der stille Anmeldeversuch fehlschlägt, können Sie optional den Anmelde-Intent senden, um eine wie unter Interaktive Anmeldung

Da sich der Status des angemeldeten Spielers ändern kann, wenn die Aktivität nicht im Vordergrund ausgeführt wird, wird empfohlen, silentSignIn() aus dem onResume() .

So melden Sie sich automatisch an:

Rufen Sie die Methode silentSignIn() für GoogleSignInClient auf, um die automatische Anmeldung zu starten. Bei diesem Aufruf wird ein Task<GoogleSignInAccount>-Objekt zurückgegeben, das GoogleSignInAccount enthält, wenn Die stille Anmeldung war erfolgreich.
Erfolg oder Fehler der Spieleranmeldung durch Überschreiben OnCompleteListener
- Wenn die Anmeldung erfolgreich war, laden Sie das GoogleSignInAccount herunter. durch Aufrufen von getResult().
- Wenn die Anmeldung nicht erfolgreich war, können Sie einen Anmelde-Intent senden, um einen interaktiven Anmeldevorgang zu starten. Eine Liste weiterer Callback-Listener, die Sie verwenden können, finden Sie in der Tasks API-Entwicklerleitfaden und Task API-Referenz

Das folgende Code-Snippet zeigt, wie Ihre App die automatische Anmeldung im Hintergrund ausführen kann:

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();
}

Schlägt die automatische Anmeldung fehl, können Sie Folgendes aufrufen: getException() bis ApiException erhalten durch den detaillierten Statuscode. Der Statuscode CommonStatusCodes.SIGN_IN_REQUIRED gibt an, dass der Spieler bei der Anmeldung eine explizite Aktion ausführen muss. In diesem Fall sollte Ihre App Starten Sie wie im nächsten Abschnitt beschrieben einen interaktiven Anmeldevorgang.

Interaktive Anmeldung wird durchgeführt

Für die Anmeldung mit Spielerinteraktion muss Ihre App den Anmelde-Intent starten. Bei Erfolg Die Google Log-in API zeigt eine Benutzeroberfläche an, auf der der Spieler zur Eingabe seiner Anmeldedaten aufgefordert wird. um sich anzumelden. Dieser Ansatz vereinfacht die Anwendungsentwicklung, da die Anmeldeaktivität z. B. wenn Sie die Google Play-Dienste aktualisieren oder Aufforderungen zur Einwilligung der Nutzer in Ihrer App einblenden müssen. Das Ergebnis wird über den onActivityResult Callback des Nutzers an.

So melden Sie sich interaktiv an:

Rufen Sie getSigninIntent() im GoogleSignInClient auf, um einen Anmelde-Intent zu erhalten, und rufen Sie dann auf startActivity() und diesen Intent übergeben. Das folgende Code-Snippet zeigt, wie Ihre App Einen interaktiven Anmeldevorgang starten:

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

In der onActivityResult() Callback verwendet, wird das Ergebnis des zurückgegebenen Intents verarbeitet.

Wenn die Anmeldung erfolgreich war, GoogleSignInAccount-Objekt aus GoogleSignInResult.
Wenn das Anmeldeergebnis nicht erfolgreich war, sollten Sie den Anmeldefehler beheben (z. B. durch wenn eine Fehlermeldung in einer Warnung angezeigt wird. Das folgende Code-Snippet zeigt, wie Ihre App die Ergebnisse der Spieleranmeldung verarbeiten kann:

@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();
    }
  }
}

Spielerinformationen werden abgerufen

Die GoogleSignInAccount, die von der Google Log-in API zurückgegeben wird, enthält keinen Player Informationen. Wenn in Ihrem Spiel Spielerinformationen wie der Anzeigename und die Spieler-ID des Spielers verwendet werden, können Sie diese Informationen wie hier beschrieben abrufen.

Sie erhalten ein PlayersClient-Objekt, indem Sie die Methode getPlayersClient() aufrufen und übergeben. GoogleSignInAccount als Parameter festlegen.
Verwenden Sie die PlayersClient-Methoden, um den Player asynchron zu laden. Objekt, das Informationen eines Spielers enthält. Sie können beispielsweise getCurrentPlayer() aufrufen. um den aktuell angemeldeten Player zu laden. Gibt die Aufgabe eine ApiException mit Statuscode von SIGN_IN_REQUIRED, bedeutet das, dass der Spieler noch einmal authentifiziert werden muss. Rufen Sie dazu GoogleSignInClient.getSignInIntent() um sich interaktiv im Player anzumelden.
Wenn die Aufgabe das Objekt Player erfolgreich zurückgibt, können Sie die Methoden der Player-Objekt, um bestimmte Spielerdetails abzurufen, z. B. getDisplayName() oder getPlayerId().

Anmeldeschaltfläche bereitstellen

Um eine standardmäßige Google-Anmeldeschaltfläche in deinem Spiel bereitzustellen, kannst du eine der diese Ansätze:

Ein com.google.android.gms.common.SignInButton-Element einschließen auf das Layout der Hauptaktivität. oder
Entwerfen Sie eine benutzerdefinierte Anmeldeschaltfläche gemäß dem Google Log-in-Branding .

Wenn Nutzer auf die Anmeldeschaltfläche klicken, sollte Ihr Spiel den Anmeldevorgang initiieren, indem eine Anmelde-Intent, wie unter Interaktive Anmeldung durchführen beschrieben.

Dieses Code-Snippet zeigt, wie Sie im onCreate() eine Anmeldeschaltfläche hinzufügen. für Ihre Aktivität verwenden.

@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);
}

Das folgende Code-Snippet zeigt, wie Sie den Anmelde-Intent senden können, wenn der Nutzer auf die Schaltfläche „Anmelden“.

@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);
  }
}

Pop-ups für Spiele anzeigen

Mithilfe der Klasse GamesClient können Sie in Ihrem Spiel Pop-up-Ansichten einblenden. Beispiel: Ihr Spiel Ein Pop-up-Fenster mit der Aufforderung „Willkommen zurück“ oder „Erfolge freigeschaltet“ kann angezeigt werden. So erlaubst du Google Play-Spieldienste: um Pop-ups in Ansichten in deinem Spiel zu öffnen, setViewForPopups() . Sie können weiter anpassen, wo das Pop-up-Fenster auf dem Bildschirm angezeigt wird, indem Sie setGravityForPopups()

Spieler abmelden

Die Abmeldung erfolgt über die Methode signOut() auf dem 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.
        }
      });
}