Diese Seite wurde von der Cloud Translation API übersetzt.

In Android-Spielen anmelden

Damit Ihr Spiel auf die Funktionen der Google Play-Spieldienste zugreifen kann, muss es das Konto des angemeldeten Spielers angeben. Wenn der Spieler nicht authentifiziert ist, kann es in Ihrem Spiel zu Fehlern beim Aufrufen der APIs der Google Play-Spieldienste kommen. In dieser Dokumentation wird beschrieben, wie Sie eine nahtlose Anmeldung in Ihrem Spiel implementieren.

Spieleranmeldung implementieren

Die Klasse GoogleSignInClient ist der Haupteinstiegspunkt, um das Konto des aktuell angemeldeten Spielers abzurufen und ihn anzumelden, falls er sich noch nicht in deiner App auf dem Gerät angemeldet hat.

So erstellen Sie einen Anmeldeclient:

Erstelle einen Anmeldeclient über das Objekt GoogleSignInOptions, wie im folgenden Code-Snippet dargestellt. Geben Sie in GoogleSignInOptions.Builder für die Anmeldung GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN an.
```
GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;
```
Wenn Sie 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 unbedingt erforderlich. Bei allen anderen Bereichen schlägt die erste stille Anmeldung fehl, mit Ausnahme von Nutzern, die sich bereits erfolgreich 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 Nutzer bereits angemeldet ist

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

Du kannst silentSignIn() aufrufen, um das Konto des aktuell angemeldeten Spielers abzurufen. Außerdem kannst du versuchen, Spieler anzumelden, ohne eine Benutzeroberfläche anzuzeigen, wenn sie sich auf einem anderen Gerät in deiner App angemeldet haben.

Die Methode silentSignIn() gibt einen Task<GoogleSignInAccount> zurück. Wenn die Aufgabe abgeschlossen ist, legen Sie das zuvor deklarierte Feld GoogleSignInAccount auf das Anmeldekonto fest, das von der Aufgabe zurückgegeben wird, oder auf null, um anzugeben, dass kein angemeldeter Nutzer vorhanden ist.

Wenn der stille Anmeldeversuch fehlschlägt, können Sie optional die Anmeldeabsicht senden, um eine Anmeldeoberfläche anzuzeigen, wie unter Interaktive Anmeldung ausführen beschrieben.

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

So führen Sie die Anmeldung im Hintergrund aus:

Rufen Sie die Methode silentSignIn() auf GoogleSignInClient, um den stummen Anmeldevorgang zu starten. Bei diesem Aufruf wird bei erfolgreicher stiller Anmeldung ein Task<GoogleSignInAccount>-Objekt zurückgegeben, das ein GoogleSignInAccount enthält.
Überschreibe OnCompleteListener, um den Erfolg oder Misserfolg der Anmeldung des Spielers zu verarbeiten.
- Wenn die Anmeldeaufgabe erfolgreich war, rufen Sie das Objekt GoogleSignInAccount durch Aufrufen von getResult() ab.
- 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 Entwicklerleitfaden für die Tasks API und in der Task API-Referenz.

Im folgenden Code-Snippet wird gezeigt, wie Ihre App eine stille Anmeldung 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();
}

Wenn der Versuch einer stillen Anmeldung fehlschlägt, kannst du getException() anrufen, um einen ApiException mit dem detaillierten Statuscode zu erhalten. Der Statuscode CommonStatusCodes.SIGN_IN_REQUIRED gibt an, dass der Spieler eine explizite Aktion zur Anmeldung ausführen muss. In diesem Fall sollte Ihre App einen interaktiven Anmeldevorgang starten, wie im nächsten Abschnitt beschrieben.

Damit sich Nutzer über die Interaktion mit dem Spieler anmelden können, muss deine App die Anmeldeabsicht starten. Bei Erfolg zeigt die Google Sign-In API eine Benutzeroberfläche an, in der der Spieler aufgefordert wird, seine Anmeldedaten einzugeben, um sich anzumelden. Dieser Ansatz vereinfacht die App-Entwicklung, da die Anmeldeaktivität Szenarien wie die Aktualisierung von Google Play-Diensten oder das Einblenden von Einwilligungsaufforderungen im Namen Ihrer App abwickelt. Das Ergebnis wird über den onActivityResult-Callback zurückgegeben.

So führen Sie die Anmeldung interaktiv aus:

Rufe getSigninIntent() auf der GoogleSignInClient auf, um einen Anmelde-Intent zu erhalten, und rufe dann startActivity() auf und übergebe diesen Intent. Das folgende Code-Snippet zeigt, wie Ihre App 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);
}

Verarbeite im Callback onActivityResult() das Ergebnis der zurückgegebenen Intent-Anfrage.

Wenn die Anmeldung erfolgreich war, hole das GoogleSignInAccount-Objekt aus dem GoogleSignInResult ab.
Wenn die Anmeldung nicht erfolgreich war, solltest du den Anmeldefehler behandeln, z. B. durch das Einblenden einer Fehlermeldung in einer Benachrichtigung. 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 abrufen

Die GoogleSignInAccount, die von der Google Sign-In API zurückgegeben wird, enthält keine Spielerinformationen. Wenn in Ihrem Spiel Spielerinformationen wie der Anzeigename und die Spieler-ID des Spielers verwendet werden, können Sie diese Informationen so abrufen:

Rufen Sie die Methode getPlayersClient() auf und übergeben Sie GoogleSignInAccount als Parameter, um ein PlayersClient-Objekt abzurufen.
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, muss der Spieler noch einmal authentifiziert werden. Rufe dazu GoogleSignInClient.getSignInIntent() auf, um dich interaktiv im Player anzumelden.
Wenn die Aufgabe das Objekt Player erfolgreich zurückgibt, kannst du die Methoden des Player-Objekts aufrufen, um bestimmte Spielerdetails abzurufen (z. B. getDisplayName() oder getPlayerId()).

Sie haben folgende Möglichkeiten, in Ihrem Spiel eine standardmäßige Google-Anmeldeschaltfläche bereitzustellen:

Fügen Sie ein com.google.android.gms.common.SignInButton in das Layout der Hauptaktivität ein.
Entwerfen Sie eine benutzerdefinierte Anmeldeschaltfläche gemäß den Markenrichtlinien für Google Log-in.

Wenn Nutzer auf die Anmeldeschaltfläche klicken, sollte Ihr Spiel den Anmeldevorgang starten, indem es eine Anmeldeabsicht sendet, wie unter Interaktive Anmeldung ausführen beschrieben.

In diesem Code-Snippet wird gezeigt, wie Sie in der Methode onCreate() eine Anmeldeschaltfläche für Ihre Aktivität hinzufügen.

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

Im folgenden Code-Snippet wird gezeigt, wie Sie die Anmeldeabsicht 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);
  }
}

Pop-ups für Spiele anzeigen

Mithilfe der Klasse GamesClient können Sie in Ihrem Spiel Pop-up-Ansichten einblenden. Beispiel: In Ihrem Spiel kann ein Pop-up mit dem Text „Willkommen zurück“ oder „Erfolge freigeschaltet“ angezeigt werden. Wenn Sie den Google Play-Spieldiensten erlauben möchten, Pop-ups in Ansichten in Ihrem Spiel zu öffnen, rufen Sie die Methode setViewForPopups() auf. Durch Aufrufen von setGravityForPopups() können Sie weiter anpassen, wo das Pop-up auf dem Bildschirm angezeigt wird.

Spieler abmelden

Zum Abmelden wird die Methode signOut() für GoogleSignInClient aufgerufen.

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