Diese Seite wurde von der Cloud Translation API übersetzt.

Anmeldung über ein verknüpftes Konto für Android

Die Anmeldung über ein verknüpftes Konto ermöglicht die Anmeldung über Google One Tap für Nutzer, die ihr Google-Konto bereits mit Ihrem Dienst verknüpft haben. So können sich Nutzer mit nur einem Klick anmelden, ohne ihren Nutzernamen und ihr Passwort noch einmal eingeben zu müssen. Außerdem verringert sich die Wahrscheinlichkeit, dass Nutzer bei Ihrem Dienst doppelte Konten erstellen.

Die Anmeldung über ein verknüpftes Konto ist Teil des Anmeldevorgangs mit nur einem Tippen für Android. Sie müssen also keine separate Bibliothek importieren, wenn die Funktion „One Tap“ bereits in Ihrer App aktiviert ist.

In diesem Dokument erfahren Sie, wie Sie Ihre Android-App so ändern, dass die Anmeldung über ein verknüpftes Konto unterstützt wird.

Funktionsweise

Sie können während der Anmeldung per One Tap die Anzeige verknüpfter Konten aktivieren.
Wenn der Nutzer bei Google angemeldet ist und sein Google-Konto mit seinem Konto in Ihrem Dienst verknüpft hat, wird ein ID-Token für das verknüpfte Konto zurückgegeben.
Dem Nutzer wird eine One Tap-Anmeldung mit der Option angezeigt, sich mit seinem verknüpften Konto in Ihrem Dienst anzumelden.
Wenn der Nutzer mit dem verknüpften Konto fortfahren möchte, wird das ID-Token des Nutzers an Ihre App zurückgegeben. Sie gleichen es mit dem Token ab, das in Schritt 2 an Ihren Server gesendet wurde, um den angemeldeten Nutzer zu identifizieren.

Einrichten

Entwicklungsumgebung einrichten

So rufen Sie die neuesten Google Play-Dienste auf Ihrem Entwicklungshost ab:

Öffnen Sie den Android SDK Manager.

Suchen Sie unter SDK-Tools nach Google Play-Dienste.
Wenn der Status dieser Pakete nicht „Installiert“ lautet, wählen Sie beide aus und klicken Sie auf Pakete installieren.

App konfigurieren

Fügen Sie in der Datei build.gradle auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects ein.
```
buildscript {
    repositories {
        google()
    }
}

allprojects {
    repositories {
        google()
    }
}
```
Fügen Sie der Gradle-Datei Ihres Moduls auf Anwendungsebene (in der Regel app/build.gradle) die Abhängigkeiten für die „Link with Google“ API hinzu:
```
dependencies {
  implementation 'com.google.android.gms:play-services-auth:21.3.0'
}
```

Android-App so ändern, dass die Anmeldung über ein verknüpftes Konto unterstützt wird

Am Ende des Anmeldevorgangs für verknüpfte Konten wird ein ID-Token an Ihre App zurückgegeben. Die Integrität des ID-Tokens sollte überprüft werden, bevor der Nutzer angemeldet wird.

Im folgenden Codebeispiel werden die Schritte zum Abrufen, Bestätigen des ID-Tokens und anschließenden Anmelden des Nutzers beschrieben.

Aktivität zum Empfangen des Ergebnisses des Intents „Anmelden“ erstellen

Kotlin

  private val activityResultLauncher = registerForActivityResult(
    ActivityResultContracts.StartIntentSenderForResult()) { result ->
    if (result.resultCode == RESULT_OK) {
      try {
        val signInCredentials = Identity.signInClient(this)
                                .signInCredentialFromIntent(result.data)
        // Review the Verify the integrity of the ID token section for
        // details on how to verify the ID token
        verifyIdToken(signInCredential.googleIdToken)
      } catch (e: ApiException) {
        Log.e(TAG, "Sign-in failed with error code:", e)
      }
    } else {
      Log.e(TAG, "Sign-in failed")
    }
  }

Java

  private final ActivityResultLauncher<IntentSenderResult>
    activityResultLauncher = registerForActivityResult(
    new ActivityResultContracts.StartIntentSenderForResult(),
    result -> {
    If (result.getResultCode() == RESULT_OK) {
        try {
          SignInCredential signInCredential = Identity.getSignInClient(this)
                         .getSignInCredentialFromIntent(result.getData());
          verifyIdToken(signInCredential.getGoogleIdToken());
        } catch (e: ApiException ) {
          Log.e(TAG, "Sign-in failed with error:", e)
        }
    } else {
        Log.e(TAG, "Sign-in failed")
    }
});

Anmeldeanfrage erstellen

Kotlin

private val tokenRequestOptions =
GoogleIdTokenRequestOptions.Builder()
  .supported(true)
  // Your server's client ID, not your Android client ID.
  .serverClientId(getString("your-server-client-id")
  .filterByAuthorizedAccounts(true)
  .associateLinkedAccounts("service-id-of-and-defined-by-developer",
                           scopes)
  .build()

Java

 private final GoogleIdTokenRequestOptions tokenRequestOptions =
     GoogleIdTokenRequestOptions.Builder()
  .setSupported(true)
  .setServerClientId("your-service-client-id")
  .setFilterByAuthorizedAccounts(true)
  .associateLinkedAccounts("service-id-of-and-defined-by-developer",
                            scopes)
  .build()

Intent „Anmeldung ausstehend“ starten

Kotlin

 Identity.signInClient(this)
    .beginSignIn(
  BeginSignInRequest.Builder()
    .googleIdTokenRequestOptions(tokenRequestOptions)
  .build())
    .addOnSuccessListener{result ->
      activityResultLauncher.launch(result.pendingIntent.intentSender)
  }
  .addOnFailureListener {e ->
    Log.e(TAG, "Sign-in failed because:", e)
  }

Java

 Identity.getSignInClient(this)
  .beginSignIn(
    BeginSignInRequest.Builder()
      .setGoogleIdTokenRequestOptions(tokenRequestOptions)
      .build())
  .addOnSuccessListener(result -> {
    activityResultLauncher.launch(
        result.getPendingIntent().getIntentSender());
})
.addOnFailureListener(e -> {
  Log.e(TAG, "Sign-in failed because:", e);
});

Integrität des ID-Tokens prüfen

Google API-Clientbibliothek verwenden

Die Java Google API-Clientbibliothek wird empfohlen, um Google-ID-Tokens in einer Produktionsumgebung zu validieren.

Java

  import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken;
  import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken.Payload;
  import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier;

  ...

  GoogleIdTokenVerifier verifier = new GoogleIdTokenVerifier.Builder(transport, jsonFactory)
      // Specify the CLIENT_ID of the app that accesses the backend:
      .setAudience(Collections.singletonList(CLIENT_ID))
      // Or, if multiple clients access the backend:
      //.setAudience(Arrays.asList(CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3))
      .build();

  // (Receive idTokenString by HTTPS POST)

  GoogleIdToken idToken = verifier.verify(idTokenString);
  if (idToken != null) {
    Payload payload = idToken.getPayload();

    // Print user identifier
    String userId = payload.getSubject();
    System.out.println("User ID: " + userId);

    // Get profile information from payload
    String email = payload.getEmail();
    boolean emailVerified = Boolean.valueOf(payload.getEmailVerified());
    String name = (String) payload.get("name");
    String pictureUrl = (String) payload.get("picture");
    String locale = (String) payload.get("locale");
    String familyName = (String) payload.get("family_name");
    String givenName = (String) payload.get("given_name");

    // Use or store profile information
    // ...

  } else {
    System.out.println("Invalid ID token.");
  }

Die Methode GoogleIdTokenVerifier.verify() überprüft die JWT-Signatur, den aud-, den iss- und den exp-Anspruch.

Wenn Sie prüfen möchten, ob das ID-Token ein Google Workspace- oder Cloud-Organisationskonto darstellt, können Sie den hd-Anspruch anhand des Domainnamens überprüfen, der von der Payload.getHostedDomain()-Methode zurückgegeben wird.