Acceso a una cuenta vinculada para Android

El Acceso con Cuenta vinculada habilita el Acceso con Google con un solo toque para los usuarios que ya tienen su Cuenta de Google vinculada a tu servicio. Esto mejora la experiencia de los usuarios, ya que pueden acceder con un clic, sin volver a ingresar su nombre de usuario y contraseña. También reduce las posibilidades de que los usuarios creen cuentas duplicadas en tu servicio.

El Acceso con cuenta vinculada está disponible como parte del flujo de Acceso con un toque para Android. Esto significa que no es necesario importar una biblioteca independiente si tu app ya tiene habilitada la función One Tap.

En este documento, aprenderás a modificar tu app para Android para que admita el acceso con cuentas vinculadas.

Cómo funciona

  1. Aceptas mostrar las cuentas vinculadas durante el flujo de acceso con un solo toque.
  2. Si el usuario accedió a Google y vinculó su Cuenta de Google con su cuenta en tu servicio, se mostrará un token de ID para la cuenta vinculada.
  3. Se le muestra al usuario un mensaje de acceso con One Tap con la opción de acceder a tu servicio con su cuenta vinculada.
  4. Si el usuario elige continuar con la cuenta vinculada, el token de ID del usuario se muestra a tu app. Debes compararlo con el token que se envió a tu servidor en el paso 2 para identificar al usuario que accedió.

Configuración

Cómo configurar tu entorno de desarrollo

Obtén la versión más reciente de los Servicios de Google Play en tu host de desarrollo:

  1. Abre el Android SDK Manager.

  1. En SDK Tools, busca Servicios de Google Play.

  2. Si el estado de estos paquetes no es Instalado, selecciónalos y haz clic en Instalar paquetes.

Cómo configurar tu app

  1. En tu archivo build.gradle a nivel de proyecto, incluye el repositorio Maven de Google en las secciones buildscript y allprojects.

    buildscript {
    repositories {
        google()
    }
}

allprojects {
    repositories {
        google()
    }
}

  2. Agrega las dependencias para la API de "Link with Google" al archivo Gradle a nivel de la app de tu módulo, que suele ser app/build.gradle:

    dependencies {
  implementation 'com.google.android.gms:play-services-auth:21.3.0'
}

Modifica tu app para Android para que admita el acceso con cuentas vinculadas

Al final del flujo de acceso con cuenta vinculada, se muestra un token de ID a tu app. Se debe verificar la integridad del token de ID antes de que el usuario acceda.

En el siguiente ejemplo de código, se detallan los pasos para recuperar, verificar el token de ID y, luego, hacer que el usuario acceda.

  1. Crea una actividad para recibir el resultado del intent de acceso

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

  2. Compila la solicitud de acceso

    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()

  3. Cómo iniciar el intent de acceso pendiente

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

Verifica la integridad del token de ID

Usa una biblioteca cliente de la API de Google

La forma recomendada de validar los tokens de ID de Google en un entorno de producción es usar la biblioteca cliente de la API de Google para Java.

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

El método GoogleIdTokenVerifier.verify() verifica la firma del JWT, el reclamo aud, el reclamo iss y el reclamo exp.

Si necesitas validar que el token de ID representa una cuenta de organización de Google Workspace o Cloud, puedes verificar el reclamo hd verificando el nombre de dominio que muestra el método Payload.getHostedDomain().