Diese Seite wurde von der Cloud Translation API übersetzt.

Die Google-Kontoverknüpfung direkt über Ihre Plattform initiieren.

Die Kontoverknüpfung kann direkt in der mobilen App vorgenommen werden. So können Nutzer ihr Konto in Ihrem Dienst mit ihrem Google-Konto verknüpfen. Über diesen Link erhält Google Zugriff auf die Daten, die der Nutzer zum Teilen erteilt hat.

Dies sind einige Vorteile für Nutzer:

Nutzer können die Kontoverknüpfung in Ihrer App starten und abschließen, in der sie bereits vertraut sind.
Nutzer benötigen keine Anmeldedaten, da sie bereits auf dem Gerät und in Ihrer mobilen App authentifiziert wurden.

Dies sind einige Vorteile für Entwickler:

Sie können festlegen, wo in Ihrer mobilen App geworben und die Kontoverknüpfung initiiert werden soll, z. B. in den Nutzereinstellungen, in Interstitials oder nach der Anmeldung eines Nutzers in Ihrer mobilen App. Wenn Sie mehrere Einstiegspunkte hinzufügen, können Sie Kontoverknüpfungen einfacher festlegen. und damit die Interaktion und die Anzahl der verknüpften Konten erhöhen.
höhere Conversion-Rate, da Nutzer die Verknüpfung in weniger Schritten abschließen können als beim webbasierten OAuth-Ablauf.
Geringer Entwicklungsaufwand für die Implementierung des Links von Ihrer Plattform (Android), da dieser Vorgang Ihre vorhandene Implementierung von OAuth2.0 nutzt, vorausgesetzt, Sie haben bereits eine implementiert.
Die Abbruchrate wurde reduziert, da Nutzer ihre Anmeldedaten nicht noch einmal eingeben müssen und den Vorgang in weniger Schritten abschließen können. Die Abbruchrate kann in Abläufen, in denen Nutzer sich zurückrufen und ihre Anmeldedaten eingeben müssen, bis zu 80% betragen.

Funktionsweise

Die Verknüpfung von Ihrer Plattform erfolgt in den folgenden Schritten:

Der Nutzer klickt oder schaltet einen Verknüpfungstrigger in Ihrer mobilen App ein oder aus.
Der Nutzer wählt das zu verknüpfende Google-Konto aus.
1. Der Nutzer wählt ein vorhandenes Google-Konto auf dem Gerät aus, um es zu verknüpfen, oder meldet sich mit einem neuen Konto an
Dem Nutzer werden von Google gehostete Einwilligungsbildschirme gezeigt und er muss zustimmen, den Vorgang fortzusetzen oder abzubrechen, um den Verknüpfungsvorgang zu beenden.
Der Nutzer sieht Ihren Zustimmungsbildschirm und muss zustimmen, um fortzufahren oder den Vorgang abzubrechen, um den Verknüpfungsvorgang zu beenden.
Die Verknüpfung wird zwischen dem Konto des Nutzers bei Ihrem Dienst und seinem Google-Konto hergestellt.

Abbildung 1. Verknüpfung aus Ihrem Plattformablauf

Voraussetzungen

Um Link über Ihre Plattform zu implementieren, benötigen Sie Folgendes:

Eine Android-App.
Sie besitzen, verwalten und warten einen OAuth 2.0-Server, der den OAuth 2.0-Autorisierungscode-Vorgang unterstützt.

Einrichtung

Bevor Sie mit den folgenden Schritten fortfahren können, müssen Sie den Registrierungsvorgang für die Kontoverknüpfung abgeschlossen haben.

Entwicklungsumgebung einrichten

Holen Sie sich die neuesten Google Play-Dienste auf Ihrem Entwicklungshost:

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

Eigene 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 die Abhängigkeiten für die „Link with Google“ API zur Gradle-Datei auf App-Ebene Ihres Moduls hinzu, die normalerweise app/build.gradle ist:
```
dependencies {
  implementation 'com.google.android.gms:play-services-auth:21.2.0'
}
```

Unterstützung für Link von deiner Plattform hinzufügen

Der Link von Ihrem Plattformablauf führt dazu, dass ein von Ihrem Dienst bereitgestelltes Zugriffstoken von Google gespeichert wird. Die Einwilligung muss eingeholt werden, bevor das Token für den Nutzer zurückgegeben werden kann.

Führen Sie die folgenden Schritte aus, um die Einwilligung des Nutzers einzuholen und über das Google Play Services SDK ein Authentifizierungscode-Token zurückzugeben.

PendingIntent erstellen, um Einwilligungsaktivität zu starten: Die Einwilligung wird über die Play Services API gestartet. Wenn die API aufgerufen wird, musst du eine PendingIntent angeben (diese wird zur Verdeutlichung als consentPendingIntent bezeichnet).
Kotlin
```
// Build a PendingIntent that can launch the consent activity
val consentPendingIntent = buildConsentPendingIntent()
```
Java
```
// Build a PendingIntent that can launch your consent activity
PendingIntent consentPendingIntent =
          buildConsentPendingIntent();
```

Entsprechende Aktivität zum Verarbeiten des Einwilligungsintents erstellen

Kotlin

  class ConsentActivity : AppCompatActivity

  private fun onConsentAccepted() {
      // Obtain a token (for simplicity, we’ll ignore the async nature
      // of the following call)
      val token = getToken()
      val intent = Intent()
                  .putExtra(SaveAccountLinkingTokenRequest.EXTRA_TOKEN,
                            token)
      setResult(Activity.RESULT_OK, intent)
      finish()
  }

  private fun onConsentRejectedOrCanceled() {
      setResult(Activity.RESULT_CANCELED)
      finish()
  }

Java

  public class ConsentActivity extends AppCompatActivity {
    ...
    private void onConsentAccepted() {
      // Obtain a token (for simplicity, we’ll ignore the async nature of
      // the following call
      String token = getToken();
      Intent intent = new Intent();
      intent.putExtra(SaveAccountLinkingTokenRequest.EXTRA_TOKEN, token);
      setResult(Activity.RESULT_OK, intent);
      finish();
    }

    private void onConsentRejectedOrCanceled() {
      setResult(Activity.RESULT_CANCELED, null);
      finish();
    }
 }

Wir gehen davon aus, dass die Methoden onConsentAccpeted() und onConsentRejectedOrCanceled() aufgerufen werden, wenn der Nutzer deine Einwilligung annimmt oder ablehnt bzw. aufbricht.

Erstellen Sie eine Anfrage zum Speichern des Tokens und übergeben Sie neben anderen Konfigurationsparametern das in Schritt 1 erstellte PendingIntent.

Kotlin

  // Create an ActivityResultLauncher which registers a callback for the
  // Activity result contract
  val activityResultLauncher = registerForActivityResult(
    ActivityResultContracts.StartIntentSenderForResult())
    { result ->
      if (result.resultCode == RESULT_OK) {
        // Successfully finished the flow and saved the token
      } else {
        // Flow failed, for example the user may have canceled the flow
      }
    }

  // Build token save request
  val request = SaveAccountLinkingTokenRequest.builder()
    .setTokenType(SaveAccountLinkingTokenRequest.TOKEN_TYPE_AUTH_CODE)
    .setConsentPendingIntent(consentPendingIntent)
    .setServiceId("service-id-of-and-defined-by-developer")
    //Set the scopes that the token is valid for on your platform
    .setScopes(scopes)
    .build()

   // Launch consent activity and retrieve token
   Identity.getCredentialSavingClient(this)
     .saveAccountLinkingToken(request)
     .addOnSuccessListener( saveAccountLinkingTokenResult -> {
        if (saveAccountLinkingTokenResult.hasResolution()) {
          val pendingIntent = saveAccountLinkingTokenResult
                              .getPendingIntent()
          val intentSenderRequest = IntentSenderRequest
                                    .Builder(pendingIntent).build()
          activityResultLauncher.launch(intentSenderRequest)
        } else {
           // This should not happen, let’s log this
           Log.e(TAG, "Failed to save token");
        }
      })
      .addOnFailureListener(e -> Log.e(TAG, “Failed to save token”, e))

Java

  // Create an ActivityResultLauncher which registers a callback for the
  // Activity result contract
  ActivityResultLauncher<IntentSenderRequest>
      activityResultLauncher =
      registerForActivityResult(new ActivityResultContracts
                                    .StartIntentSenderForResult(),
                                result -> {
      if (result.getResultCode() == RESULT_OK) {
          // Successfully finished the flow and saved the token
      } else {
          // Flow failed, for example the user may have canceled the flow
      }
  });

 // Build token save request
 SaveAccountLinkingTokenRequest request =
    SaveAccountLinkingTokenRequest.builder()
        .setTokenType(
            SaveAccountLinkingTokenRequest.TOKEN_TYPE_AUTH_CODE)
        .setConsentPendingIntent(consentPendingIntent)
        .setServiceId("service-id-of-and-defined-by-developer")
        //Set the scopes that the token is valid for on your platform
        .setScopes(scopes)
        .build();

  // Launch consent activity and retrieve token
  Identity.getCredentialSavingClient(this)
      .saveAccountLinkingToken(request)
      .addOnSuccessListener(
          saveAccountLinkingTokenResult -> {
            if (saveAccountLinkingTokenResult.hasResolution()) {
              // Launch the resolution intent
              PendingIntent pendingIntent =
                  saveAccountLinkingTokenResult.getPendingIntent();
              IntentSenderRequest intentSenderRequest =
                  new IntentSenderRequest.Builder(pendingIntent).build();
              activityResultLauncher.launch(intentSenderRequest);
            } else {
              // This should not happen, let’s log this
              Log.e(TAG, "Failed to save token");
            }
          })
      .addOnFailureListener(e -> Log.e(TAG, "Failed to save token", e));
  ```

Bei den obigen Schritten wird der Nutzer um seine Einwilligung gebeten und ein Autorisierungscode an Google gesendet.

Best Practices

In Ihrer App sollte der Linkstatus für Nutzer über eine Schaltfläche, Ein/Aus-Schaltfläche oder ein ähnliches visuelles Element angegeben werden.

Abbildung 1. Beispielbild für Linkstatus
Sie sollten den Nutzer nach einem erfolgreichen Link benachrichtigen, z.B. Ein Toast anzuzeigen, eine Statusänderung umschalten oder den Nutzer zu einer separaten Seite für erfolgreiche Links weiterzuleiten.
Sie sollten In-App-Nutzer dazu auffordern, ihre Konten zu verknüpfen – idealerweise aufgrund starker Signale, von denen die Verknüpfung für diese Nutzer profitieren würde.
Nach der erfolgreichen Verknüpfung sollten Sie Nutzern zeigen, was sie mit dem verknüpften Konto tun können, z.B. Wenn Sie gerade einen Musik-Streamingdienst verknüpft haben, bitten Sie Google Assistant, Musik abzuspielen.
Nutzern die Verwaltung ihrer verknüpften Konten ermöglichen, einschließlich der Option zum Aufheben der Verknüpfung Verweisen Sie ihn auf die Verwaltungsseite für verknüpfte Google-Konten (https://myaccount.google.com/accountlinking).

Referenz

Referenzdokumentation zur Android Auth API