In Android-Spielen anmelden

Nach der Einstellung der Google-Anmeldung-API wird das games v1 SDK im Jahr 2026 entfernt. Ab Februar 2025 kannst du bei Google Play keine Titel mehr veröffentlichen, die neu in Games SDK V1 integriert wurden. Wir empfehlen, stattdessen das Games SDK V2 zu verwenden.
Bestehende Titel mit den vorherigen Integrationen für Spiele v1 funktionieren zwar noch einige Jahre, aber wir empfehlen Ihnen, ab Juni 2025 zu Version 2 zu migrieren.
In diesem Leitfaden wird die Verwendung des Play Games Services SDK V1 beschrieben. Informationen zur neuesten SDK-Version finden Sie in der Dokumentation zu Version 2.

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, können in Ihrem Spiel Fehler auftreten, wenn Aufrufe an die Google Play Games Services APIs erfolgen. 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 den Spieler anzumelden, falls er dies noch nicht in Ihrer App auf dem Gerät getan hat.

Hinweis :Die Klasse GoogleSignInClient verwendet die Klasse Task der Google Play-Dienste, um Ergebnisse asynchron zurückzugeben. Weitere Informationen zur Verwendung von Aufgaben zum Verwalten von Threads finden Sie im Entwicklerleitfaden zur Tasks API.

So erstellen Sie einen Anmeldeclient:

1. Erstellen Sie einen Anmeldeclient über das Objekt GoogleSignInOptions, wie im folgenden Code-Snippet gezeigt. Wenn Sie die Anmeldung in GoogleSignInOptions.Builder konfigurieren möchten, müssen Sie GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN angeben.

   GoogleSignInOptions signInOptions = GoogleSignInOptions.DEFAULT_GAMES_SIGN_IN;

2. Wenn Sie SnapshotsClient verwenden möchten, fügen Sie .requestScopes(Games.SCOPE_GAMES_SNAPSHOTS) zu Ihrem 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. Jeder andere Bereich führt dazu, dass die erste stille Anmeldung fehlschlägt, mit Ausnahme von Nutzern, die sich bereits auf einem anderen Gerät erfolgreich angemeldet haben.

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 Spieler bereits angemeldet ist

Mit GoogleSignIn.getLastSignedInAccount() können Sie prüfen, ob ein Konto bereits auf dem aktuellen Gerät angemeldet ist, und mit GoogleSignIn.hasPermissions(), ob diesem Konto bereits die erforderlichen Berechtigungen erteilt wurden. Wenn beide Bedingungen zutreffen, d. h. getLastSignedInAccount() einen Wert ungleich null zurückgibt und hasPermissions() true zurückgibt, können Sie das von getLastSignedInAccount() zurückgegebene Konto bedenkenlos verwenden, auch wenn das Gerät offline ist.

Stille Anmeldung durchführen

Sie können silentSignIn() aufrufen, um das Konto des aktuell angemeldeten Spielers abzurufen, und versuchen, Spieler ohne Anzeige einer Benutzeroberfläche anzumelden, wenn sie sich auf einem anderen Gerät erfolgreich in Ihrer App angemeldet haben.

Die Methode silentSignIn() gibt eine Task<GoogleSignInAccount> zurück. Wenn der Task abgeschlossen ist, legen Sie das Feld GoogleSignInAccount, das Sie zuvor deklariert haben, auf das Anmeldekonto fest, das vom Task als Ergebnis 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 durchführen beschrieben.

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

So führen Sie die Anmeldung im Hintergrund aus:

1. Rufen Sie die Methode silentSignIn() für GoogleSignInClient auf, um den automatischen Anmeldevorgang zu starten. Bei diesem Aufruf wird ein Task<GoogleSignInAccount>-Objekt zurückgegeben, das ein GoogleSignInAccount enthält, wenn die stille Anmeldung erfolgreich ist.
2. Behandle den Erfolg oder Misserfolg der Spieleranmeldung, indem du OnCompleteListener überschreibst.
   • Wenn die Anmeldeaufgabe erfolgreich war, rufen Sie das GoogleSignInAccount-Objekt mit getResult() ab.
   • Wenn die Anmeldung nicht erfolgreich war, können Sie eine 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.

Das folgende Code-Snippet zeigt, wie Ihre App eine 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 stille Anmeldeversuch fehlschlägt, können Sie getException() aufrufen, um ein ApiException mit dem detaillierten Statuscode zu erhalten. Ein Statuscode von CommonStatusCodes.SIGN_IN_REQUIRED weist darauf hin, dass der Spieler explizit Maßnahmen ergreifen muss, um sich anzumelden. In diesem Fall sollte Ihre App einen interaktiven Anmeldevorgang starten, wie im nächsten Abschnitt beschrieben.

Interaktive Anmeldung durchführen

Wenn sich Nutzer über die Spielerinteraktion anmelden sollen, muss Ihre App den Anmelde-Intent starten. Bei Erfolg wird über die Google Sign-In API eine Benutzeroberfläche angezeigt, in der der Spieler aufgefordert wird, seine Anmeldedaten einzugeben. Dieser Ansatz vereinfacht die App-Entwicklung, da die Anmeldeaktivität Szenarien wie das Aktualisieren der Google Play-Dienste oder das Anzeigen von Einwilligungsaufforderungen in Ihrem Namen übernimmt. Das Ergebnis wird über den Callback onActivityResult zurückgegeben.

So melden Sie sich interaktiv an:

1. Rufen Sie getSigninIntent() für die GoogleSignInClient auf, um einen Anmelde-Intent zu erhalten, und rufen Sie dann startActivity() auf und übergeben Sie 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);
   }

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

   • Wenn die Anmeldung erfolgreich war, rufen Sie das GoogleSignInAccount-Objekt aus GoogleSignInResult ab.
   • Wenn die Anmeldung nicht erfolgreich war, sollten Sie den Anmeldefehler behandeln, z. B. indem Sie eine Fehlermeldung in einem Hinweis anzeigen. 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 abrufen

Das GoogleSignInAccount, das von der Google Sign-In API zurückgegeben wird, enthält keine Spielerinformationen. Wenn in Ihrem Spiel Spielerinformationen wie den Anzeigenamen und die Spieler-ID verwendet werden, können Sie diese Informationen mit den folgenden Schritten abrufen.

Hinweis :Die vom Android SDK zurückgegebene Spieler‑ID sollte nicht im Back-End des Spiels gespeichert werden, da sie von einem nicht vertrauenswürdigen Gerät manipuliert werden kann. Stattdessen sollten Sie den serverseitigen API-Zugriff aktivieren und die Spieler-ID oder andere Daten mit einem serverseitigen Aufruf direkt aus dem Backend des Spiels abrufen.

1. Rufen Sie ein PlayersClient-Objekt ab, indem Sie die Methode getPlayersClient() aufrufen und GoogleSignInAccount als Parameter übergeben.
2. Verwenden Sie die PlayersClient-Methoden, um das Player-Objekt, das die Informationen eines Spielers enthält, asynchron zu laden. Sie können beispielsweise getCurrentPlayer() aufrufen, um den aktuell angemeldeten Spieler zu laden. Wenn für die Aufgabe ApiException mit dem Statuscode SIGN_IN_REQUIRED zurückgegeben wird, muss der Spieler neu authentifiziert werden. Rufen Sie dazu GoogleSignInClient.getSignInIntent() auf, um den Nutzer interaktiv im Player anzumelden.
3. Wenn die Aufgabe das Player-Objekt zurückgibt, können Sie die Methoden des Player-Objekts aufrufen, um bestimmte Spielerdetails abzurufen, z. B. getDisplayName() oder getPlayerId().

Anmeldeschaltfläche bereitstellen

Wenn Sie in Ihrem Spiel eine standardmäßige Google-Anmeldeschaltfläche einfügen möchten, können Sie eine der folgenden Methoden verwenden:

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

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

In diesem Code-Snippet sehen Sie, wie Sie der onCreate()-Methode für Ihre Aktivität eine Anmeldeschaltfläche 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);
}

Das folgende Code-Snippet zeigt, wie Sie die Anmeldeabsicht senden können, 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. So kann in Ihrem Spiel beispielsweise ein Pop-up mit der Meldung „Willkommen zurück“ oder „Erfolge freigeschaltet“ angezeigt werden. Damit Google Play-Spieldienste Pop-ups in Ansichten in Ihrem Spiel starten können, rufen Sie die Methode setViewForPopups() auf. Sie können die Position des Pop-ups auf dem Bildschirm weiter anpassen, indem Sie setGravityForPopups() aufrufen.

Player abmelden

Die Abmeldung erfolgt durch Aufrufen der Methode signOut() für 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.
        }
      });
}