In Android-Spielen anmelden

Damit auf die Funktionen der Google Play-Spieldienste zugegriffen werden kann, muss Ihr Spiel das Konto des angemeldeten Spielers angeben. 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 Ihrem Spiel 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:

  1. Erstellen Sie einen Anmeldeclient über das 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;

  2. 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();

  3. 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.

Stumme Anmeldung wird durchgeführt

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, 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 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 melden Sie sich automatisch an:

  1. 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.
  2. Überschreibe OnCompleteListener, um den Erfolg oder Misserfolg der Anmeldung des Spielers zu verarbeiten.
    • Wenn die Anmeldung erfolgreich war, laden Sie das GoogleSignInAccount herunter. durch Aufrufen von getResult().
    • 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.

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. 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.

Interaktive Anmeldung ausführen

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 der Google Play-Dienste 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:

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

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

    • Wenn die Anmeldung erfolgreich war, GoogleSignInAccount-Objekt aus GoogleSignInResult.
    • 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:

  1. Sie erhalten ein PlayersClient-Objekt, indem Sie die Methode getPlayersClient() aufrufen und übergeben. GoogleSignInAccount als Parameter festlegen.
  2. Verwenden Sie die PlayersClient-Methoden, um den Player asynchron zu laden. Objekt, das Informationen eines Spielers enthält. Du kannst beispielsweise getCurrentPlayer() aufrufen, um den aktuell angemeldeten Spieler zu laden. Gibt die Aufgabe ein 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.
  3. 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().

Anmeldeschaltfläche bereitstellen

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

Wenn Nutzer auf die Anmeldeschaltfläche klicken, sollte Ihr Spiel den Anmeldevorgang initiieren, indem eine Anmelde-Intent, wie unter Interaktive Anmeldung durchfü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);
  }
}

Anzeige von Pop-ups für Spiele

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