Acceso a una cuenta vinculada para Android

El acceso con cuentas vinculadas habilita el Acceso con Google con un 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 solo 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 cuentas vinculadas está disponible como parte del flujo de acceso con One Tap para Android. Esto significa que no necesitas importar una biblioteca independiente si tu app ya tiene habilitada la función de 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 One Tap.
  2. Si el usuario accedió a Google y vinculó su Cuenta de Google con su cuenta en tu servicio, se devolverá un token de ID para la cuenta vinculada.
  3. Se le muestra al usuario un mensaje de acceso con One Tap con una opción para acceder a tu servicio con su cuenta vinculada.
  4. Si el usuario decide continuar con la cuenta vinculada, se devuelve el token de ID del usuario a tu app. Debes compararlo con el token que se envió a tu servidor en el paso 2 para identificar al usuario conectado.

Configuración

Para configurar el Acceso con cuentas vinculadas, configura tu entorno de desarrollo y tu app.

Configura 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 SDK Manager de Android.

  1. En herramientas del SDK, 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 el archivo build.gradle a nivel del proyecto, incluye el repositorio de Maven de Google en las secciones buildscript y allprojects.

    buildscript {
    repositories {
        google()
    }
}

allprojects {
    repositories {
        google()
    }
}

  2. Agrega las dependencias de la API de "Vincular con 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 cuentas vinculadas, se devuelve un token de ID a tu app. Se debe verificar la integridad del token de ID antes de que el usuario acceda.

En la siguiente muestra 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. Crea 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. Inicia el intent pendiente de acceso

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

Verificar 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, la reclamación aud, la reclamación iss y la reclamación exp.

Si necesitas validar que el token de ID represente una cuenta de organización de Google Workspace o Cloud, puedes verificar la reclamación hd comprobando el nombre de dominio que devuelve el método Payload.getHostedDomain().