Diese Seite wurde von der Cloud Translation API übersetzt.

In Android Games anmelden

Damit Sie auf die Funktionen der Google Play-Spieldienste zugreifen können, muss Ihr Spiel das Konto des angemeldeten Spielers enthalten. Wenn der Spieler nicht authentifiziert ist, können beim Aufrufen der Google Play-Spieldienste-APIs Fehler in Ihrem Spiel auftreten. In dieser Dokumentation wird beschrieben, wie Sie eine nahtlose Anmeldung in Ihrem Spiel implementieren.

Spieleranmeldung implementieren

Die Klasse GoogleSignInClient ist der Haupteinstiegspunkt zum Abrufen des Kontos des aktuell angemeldeten Spielers und zum Anmelden des Players in der App auf dem Gerät, falls er dies noch nicht getan hat.

So erstellen Sie einen Anmeldeclient:

Erstellen Sie einen Anmeldeclient über das Objekt GoogleSignInOptions, wie im folgenden Code-Snippet gezeigt. Geben Sie in der GoogleSignInOptions.Builder zum Konfigurieren Ihrer Anmeldung GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN an.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Wenn Sie einen SnapshotsClient verwenden möchten, fügen Sie .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) zu GoogleSignInOptions.Builder hinzu, wie 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 Bereiche oder Google-Profildaten an, es sei denn, sie sind für Ihren Anwendungsfall erforderlich. Bei jedem anderen Bereich schlägt die erstmalige stille Anmeldung fehl, mit Ausnahme von Nutzern, die sich bereits auf einem anderen Gerät angemeldet haben.
Rufen Sie die Methode GoogleSignIn.getClient() auf und übergeben Sie die Optionen, die Sie in den vorherigen Schritten konfiguriert haben. Wenn der Aufruf erfolgreich ist, gibt die Google Log-in API eine Instanz von GoogleSignInClient zurück.

Prüfen, ob der Spieler bereits angemeldet ist

Mit GoogleSignIn.getLastSignedInAccount() können Sie prüfen, ob ein Konto bereits auf dem aktuellen Gerät angemeldet ist und ob diesem Konto bereits die erforderlichen Berechtigungen mit GoogleSignIn.hasPermissions() gewährt wurden. Wenn beide Bedingungen erfüllt sind, also getLastSignedInAccount() einen Wert zurückgibt, der nicht null ist, und hasPermissions() den Wert true zurückgibt, können Sie das von getLastSignedInAccount() zurückgegebene Konto bedenkenlos verwenden, auch wenn das Gerät offline ist.

Anmeldung im Hintergrund

Du kannst silentSignIn() aufrufen, um das Konto des aktuell angemeldeten Spielers abzurufen. Ist die Anmeldung auf einem anderen Gerät erfolgreich, versuchen Nutzer, sich anzumelden, ohne dass eine Benutzeroberfläche angezeigt wird.

Die Methode silentSignIn() gibt eine Task<GoogleSignInAccount> zurück. Wenn die Aufgabe abgeschlossen ist, legen Sie das zuvor deklarierte Feld GoogleSignInAccount für das Anmeldekonto fest, das als Ergebnis zurückgegeben wird, oder auf null, was bedeutet, dass kein angemeldeter Nutzer vorhanden ist.

Wenn der stille Anmeldeversuch fehlschlägt, können Sie optional den Anmelde-Intent senden, um eine Benutzeroberfläche für die Anmeldung anzuzeigen, wie unter Interaktive Anmeldung durchführen beschrieben.

Da sich der Status des angemeldeten Players ändern kann, wenn die Aktivität nicht im Vordergrund ausgeführt wird, empfehlen wir, silentSignIn() über die Methode onResume() der Aktivität aufzurufen.

So führen Sie die Anmeldung im Hintergrund durch:

Rufen Sie die Methode silentSignIn() auf der GoogleSignInClient auf, um den stillen Anmeldevorgang zu starten. Dieser Aufruf gibt ein Task<GoogleSignInAccount>-Objekt zurück, das ein GoogleSignInAccount enthält, wenn die automatische Anmeldung erfolgreich war.
Behandeln Sie den Erfolg oder Misserfolg der Spieleranmeldung, indem Sie OnCompleteListener überschreiben.
- Wenn die Anmeldung erfolgreich war, rufen Sie das Objekt GoogleSignInAccount ab, indem Sie getResult() aufrufen.
- Wenn die Anmeldung nicht erfolgreich war, können Sie einen Anmelde-Intent senden, um einen interaktiven Anmeldevorgang zu starten. Eine Liste der zusätzlichen Callback-Listener, die Sie verwenden können, finden Sie im Tasks API-Entwicklerleitfaden und in der Task-API-Referenz.

Das folgende Code-Snippet zeigt, wie die Anwendung die automatische Anmeldung durchfü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();
}

Wenn der Anmeldeversuch fehlschlägt, können Sie getException() aufrufen, um ein ApiException mit dem detaillierten Statuscode abzurufen. Der Statuscode CommonStatusCodes.SIGN_IN_REQUIRED gibt an, dass der Spieler eine explizite Aktion zur Anmeldung ausführen muss. In diesem Fall sollte Ihre Anwendung einen interaktiven Anmeldevorgang starten, wie im nächsten Abschnitt beschrieben.

Interaktive Anmeldung

Damit du dich mit der Spielerinteraktion anmelden kannst, muss deine App den Anmelde-Intent starten. Bei Erfolg zeigt die Google Log-in API eine Benutzeroberfläche an, auf der der Spieler aufgefordert wird, seine Anmeldedaten einzugeben. Dieser Ansatz vereinfacht die Anwendungsentwicklung, da die Anmeldeaktivität Szenarien wie die Aktualisierung von Google Play-Diensten oder das Einblenden von Aufforderungen zur Einwilligung im Namen Ihrer App abwickelt. Das Ergebnis wird über den onActivityResult-Callback zurückgegeben.

So führen Sie die Anmeldung interaktiv aus:

Rufen Sie getSigninIntent() auf dem GoogleSignInClient auf, um einen Anmelde-Intent abzurufen. Rufen Sie dann startActivity() auf und übergeben Sie diesen Intent. Das folgende Code-Snippet zeigt, wie Ihre Anwendung einen interaktiven Anmeldevorgang starten kann:
```
private void startSignInIntent() {
  GoogleSignInClient signInClient = GoogleSignIn.getClient(this,
      GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN);
  Intent intent = signInClient.getSignInIntent();
  startActivityForResult(intent, RC_SIGN_IN);
}
```

Verarbeiten Sie im onActivityResult()-Callback das Ergebnis des zurückgegebenen Intents.

Wenn das Anmeldeergebnis erfolgreich war, rufen Sie das Objekt GoogleSignInAccount aus GoogleSignInResult ab.
Wenn das Anmeldeergebnis nicht erfolgreich war, solltest du den Anmeldefehler beheben, z. B. indem du eine Fehlermeldung in einer Benachrichtigung angezeigt hast. Das folgende Code-Snippet zeigt, wie deine 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 keine Spielerinformationen. Wenn für Ihr Spiel Spielerinformationen wie der Anzeigename und die Spieler-ID des Spielers verwendet werden, können Sie diese Informationen so abrufen:

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

Anmeldeschaltfläche bereitstellen

Sie haben folgende Möglichkeiten, eine Standard-Anmeldeschaltfläche von Google in Ihrem Spiel bereitzustellen:

Füge com.google.android.gms.common.SignInButton in das Layout der Hauptaktivität ein oder
Gestalte eine benutzerdefinierte Anmeldeschaltfläche gemäß den Branding-Richtlinien für Google Log-in.

Wenn Nutzer auf die Anmeldeschaltfläche klicken, sollte dein Spiel den Anmeldevorgang starten. Dazu wird ein Anmelde-Intent gesendet, wie unter Interaktive Anmeldung durchführen beschrieben.

Dieses Code-Snippet zeigt, wie Sie in der Methode onCreate() für Ihre Aktivität eine Anmeldeschaltfläche hinzufügen können.

@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, wenn der Nutzer auf die Anmeldeschaltfläche klickt.

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

Spiel-Pop-ups anzeigen

Sie können Pop-up-Aufrufe in Ihrem Spiel mithilfe der Klasse GamesClient anzeigen lassen. Ihr Spiel kann beispielsweise das Pop-up „Willkommen zurück“ oder „Erfolg freigeschaltet“ anzeigen. Damit Google Play-Spieldienste Pop-ups in Ansichten in Ihrem Spiel starten können, rufen Sie die Methode setViewForPopups() auf. Durch Aufrufen von setGravityForPopups() lässt sich die Position des Pop-ups auf dem Bildschirm weiter anpassen.

Spieler abmelden

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