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 :Fordere keine anderen Zugriffsbereiche oder Google-Profildaten an, es sei denn, sie sind für deinen Anwendungsfall unerlässlich. Bei allen anderen Bereichen schlägt die stille Anmeldung beim ersten Mal 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 Sign-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 mit GoogleSignIn.hasPermissions(), ob dieses Konto bereits die erforderlichen Berechtigungen hat. 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, und versuchen, Spieler ohne Anzeige einer Benutzeroberfläche anzumelden, wenn sie sich bereits 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 die Aufgabe als Ergebnis zurückgibt, oder auf null, um anzugeben, dass kein Nutzer angemeldet 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 sich die Aktivität nicht im Vordergrund befindet, empfehlen wir, silentSignIn() über die Methode onResume() 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. Dieser Aufruf gibt ein Task<GoogleSignInAccount>-Objekt zurück, das ein GoogleSignInAccount enthält, wenn die stille Anmeldung erfolgreich war.
Überschreibe OnCompleteListener, um den Erfolg oder Misserfolg der Anmeldung des Spielers zu verarbeiten.
- Wenn die Anmeldung erfolgreich war, ruf getResult() auf, um das GoogleSignInAccount-Objekt abzurufen.
- Wenn die Anmeldung nicht erfolgreich war, kannst du eine Anmeldeabsicht 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. Ein Statuscode von CommonStatusCodes.SIGN_IN_REQUIRED weist darauf hin, dass der Nutzer eine explizite Aktion ausführen muss, um sich anzumelden. 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 Callback onActivityResult 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 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 den Player interaktiv anzumelden.
Wenn die Aufgabe das Player-Objekt 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

Mit der Klasse GamesClient können Sie Pop-up-Ansichten in Ihrem Spiel anzeigen. Ihr Spiel kann beispielsweise ein Pop-up mit der Meldung „Willkommen zurück“ oder „Erfolge freigeschaltet“ anzeigen. Wenn Sie zulassen möchten, dass die Google Play-Spieldienste Pop-ups in Ansichten in Ihrem Spiel anzeigen, rufen Sie die Methode setViewForPopups() auf. Sie können anpassen, wo das Pop-up auf dem Bildschirm angezeigt wird, indem Sie setGravityForPopups() aufrufen.

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