Crea cuentas nuevas con un solo toque

Si admites el acceso con Cuentas de Google, puedes usar el cliente de Acceso con un toque para brindarles a tus usuarios una experiencia de creación de cuentas sin inconvenientes que nunca los saque del contexto de tu app.

IU de registro con One Tap

Cuando muestras la IU de One Tap, se les solicita a los usuarios que creen una cuenta nueva con tu app usando una de las Cuentas de Google de su dispositivo. Si el usuario decide continuar, obtendrás un token de ID con información básica del perfil (su nombre, foto de perfil y dirección de correo electrónico verificada) que puedes usar para crear la cuenta nueva.

La implementación de la creación de cuentas con One Tap consta de dos partes:

  • Integrar el cliente de One Tap en tu app, lo que se describe en esta página Este proceso es, en su mayor parte, igual al de acceso con One Tap, pero con algunas diferencias en la configuración.
  • Agregar a tu backend la capacidad de crear cuentas de usuario a partir de tokens de ID de Google, lo que se analiza en Usa tokens de ID en el backend

¿Dónde debo usar el registro con One Tap?

El lugar más eficaz para ofrecer el registro con One Tap a los usuarios es en un contexto en el que el acceso habilite funciones nuevas. Primero, intenta que el usuario acceda con una credencial guardada. Si no se encuentran credenciales guardadas, ofrece crear una cuenta nueva para el usuario.

Antes de comenzar

Configura tu proyecto de la consola de Google Cloud y el proyecto de Android como se describe en Comienza a usar el acceso con One Tap.

1. Configura el cliente de One Tap

Para configurar el cliente de One Tap para la creación de cuentas, haz lo siguiente:

  • No habilites las solicitudes de credenciales de contraseña. (El registro con One Tap solo es posible con la autenticación basada en tokens).

  • Habilita las solicitudes de tokens de ID de Google con setGoogleIdTokenRequestOptions() y estos parámetros de configuración:

Java

public class YourActivity extends AppCompatActivity {

    // ...

    private SignInClient oneTapClient;
    private BeginSignInRequest signUpRequest;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState,
                         @Nullable PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        oneTapClient = Identity.getSignInClient(this);
        signUpRequest = BeginSignInRequest.builder()
                .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
                        .setSupported(true)
                        // Your server's client ID, not your Android client ID.
                        .setServerClientId(getString(R.string.your_web_client_id))
                        // Show all accounts on the device.
                        .setFilterByAuthorizedAccounts(false)
                        .build())
                .build();

        // ...
    }
}

Kotlin

class YourActivity : AppCompatActivity() {
      // ...

      private lateinit var oneTapClient: SignInClient
      private lateinit var signUpRequest: BeginSignInRequest

      override fun onCreate(savedInstanceState: Bundle?) {
          super.onCreate(savedInstanceState)
          setContentView(R.layout.activity_main)

          oneTapClient = Identity.getSignInClient(this)
          signUpRequest = BeginSignInRequest.builder()
              .setGoogleIdTokenRequestOptions(
                  BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                      .setSupported(true)
                      // Your server's client ID, not your Android client ID.
                      .setServerClientId(getString(R.string.your_web_client_id))
                      // Show all accounts on the device.
                      .setFilterByAuthorizedAccounts(false)
                      .build())
              .build()
          // ...
      }
      // ...
  }

2. Cómo hacer un seguimiento de la cancelación de la IU de One Tap

Debes hacer un seguimiento de si el usuario ya rechazó usar el registro con One Tap, ya sea cerrando el mensaje o presionando fuera de él. Por ejemplo, puedes usar una propiedad booleana de tu actividad. (consulta Cómo dejar de mostrar la IU de One Tap, más abajo).

3. Muestra la IU de registro con One Tap

Si el usuario no rechazó usar One Tap para crear una cuenta nueva, llama al método beginSignIn() del objeto cliente y adjunta objetos de escucha al Task que devuelve. Por lo general, las apps realizan este paso cuando una solicitud de acceso con One Tap no encuentra ninguna credencial guardada, es decir, en el objeto de escucha de errores de la solicitud de acceso:

  • Receptor de éxito: El cliente de One Tap llama al receptor de éxito si el usuario tiene una o más Cuentas de Google configuradas en el dispositivo. En el objeto de escucha de éxito, obtén el intent pendiente del resultado de Task y pásalo a startIntentSenderForResult() para iniciar la IU de One Tap.

  • Objeto de escucha de errores: Si el usuario no tiene ninguna Cuenta de Google en el dispositivo, el cliente de One Tap llama al objeto de escucha de errores. En este caso, no es necesario realizar ninguna acción: sigue presentando la experiencia de salida de la app, y el usuario podrá registrarse con tu flujo normal de creación de cuentas.

Java

oneTapClient.beginSignIn(signUpRequest)
        .addOnSuccessListener(this, new OnSuccessListener<BeginSignInResult>() {
            @Override
            public void onSuccess(BeginSignInResult result) {
                try {
                    startIntentSenderForResult(
                            result.getPendingIntent().getIntentSender(), REQ_ONE_TAP,
                            null, 0, 0, 0);
                } catch (IntentSender.SendIntentException e) {
                    Log.e(TAG, "Couldn't start One Tap UI: " + e.getLocalizedMessage());
                }
            }
        })
        .addOnFailureListener(this, new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                // No Google Accounts found. Just continue presenting the signed-out UI.
                Log.d(TAG, e.getLocalizedMessage());
            }
        });

Kotlin

oneTapClient.beginSignIn(signUpRequest)
    .addOnSuccessListener(this) { result ->
        try {
            startIntentSenderForResult(
                result.pendingIntent.intentSender, REQ_ONE_TAP,
                null, 0, 0, 0)
        } catch (e: IntentSender.SendIntentException) {
            Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
        }
    }
    .addOnFailureListener(this) { e ->
        // No Google Accounts found. Just continue presenting the signed-out UI.
        Log.d(TAG, e.localizedMessage)
    }

4. Cómo controlar la respuesta del usuario

La respuesta del usuario al mensaje de registro con One Tap se informará a tu app con el método onActivityResult() de tu Activity. Si el usuario eligió crear una cuenta, el resultado será un token de ID de Google. Si el usuario rechazó registrarse, ya sea cerrando la IU de One Tap o presionando fuera de ella, el resultado se devolverá con el código RESULT_CANCELED. Tu app debe controlar ambas posibilidades.

Crea una cuenta con un token de ID de Google

Si el usuario eligió registrarse con una Cuenta de Google, puedes obtener un token de ID para el usuario pasando los datos del intent de onActivityResult() al método getSignInCredentialFromIntent() del cliente de One Tap. La credencial tendrá una propiedad googleIdToken no nula.

Usa el token de ID para crear una cuenta en tu backend (consulta Autentica con un backend usando tokens de ID) y haz que el usuario acceda.

La credencial también contiene los detalles adicionales que hayas solicitado, como el número de teléfono verificado de la cuenta, si está disponible.

Java

public class YourActivity extends AppCompatActivity {

    // ...
    private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
    private boolean showOneTapUI = true;
    // ...

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        switch (requestCode) {
            case REQ_ONE_TAP:
                try { 
                    SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                    String idToken = credential.getGoogleIdToken();
                    if (idToken !=  null) {
                        // Got an ID token from Google. Use it to authenticate
                        // with your backend.
                        Log.d(TAG, "Got ID token.");
                    }
                } catch (ApiException e) {
                    // ...
                }
                break;
        }
    }
}

Kotlin

class YourActivity : AppCompatActivity() {

      // ...
      private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
      private var showOneTapUI = true
      // ...

      override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
          super.onActivityResult(requestCode, resultCode, data)

          when (requestCode) {
               REQ_ONE_TAP -> {
                  try { 
                      val credential = oneTapClient.getSignInCredentialFromIntent(data)
                      val idToken = credential.googleIdToken
                      when {
                          idToken != null -> {
                              // Got an ID token from Google. Use it to authenticate
                              // with your backend.
                              Log.d(TAG, "Got ID token.")
                          }
                          else -> {
                              // Shouldn't happen.
                              Log.d(TAG, "No ID token!")
                          }
                      }
                  } catch (e: ApiException) {
                      // ...
              }
          }
      }
      // ...
  }

Cómo dejar de mostrar la IU de One Tap

Si el usuario rechazó acceder, la llamada a getSignInCredentialFromIntent() arrojará una ApiException con un código de estado CommonStatusCodes.CANCELED. Cuando esto suceda, debes dejar de mostrar temporalmente la IU de acceso con One Tap para no molestar a los usuarios con mensajes repetidos. En el siguiente ejemplo, se logra esto configurando una propiedad en la actividad, que se usa para determinar si se debe ofrecer al usuario el acceso con One Tap. Sin embargo, también puedes guardar un valor en SharedPreferences o usar algún otro método.

Es importante que implementes tu propio límite de frecuencia para los mensajes de acceso con One Tap. Si no lo haces y un usuario cancela varios mensajes seguidos, el cliente de One Tap no le mostrará mensajes durante las próximas 24 horas.

Java

public class YourActivity extends AppCompatActivity {

    // ...
    private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
    private boolean showOneTapUI = true;
    // ...

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        switch (requestCode) {
            case REQ_ONE_TAP:
                try {
                    // ...
                } catch (ApiException e) {
                    switch (e.getStatusCode()) {
                        case CommonStatusCodes.CANCELED:
                            Log.d(TAG, "One-tap dialog was closed.");
                            // Don't re-prompt the user.
                            showOneTapUI = false;
                            break;
                        case CommonStatusCodes.NETWORK_ERROR:
                            Log.d(TAG, "One-tap encountered a network error.");
                            // Try again or just ignore.
                            break;
                        default:
                            Log.d(TAG, "Couldn't get credential from result."
                                    + e.getLocalizedMessage());
                            break;
                    }
                }
                break;
        }
    }
}

Kotlin

class YourActivity : AppCompatActivity() {

      // ...
      private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
      private var showOneTapUI = true
      // ...

      override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
          super.onActivityResult(requestCode, resultCode, data)

          when (requestCode) {
              REQ_ONE_TAP -> {
                  try {
                      // ...
                  } catch (e: ApiException) {
                      when (e.statusCode) {
                          CommonStatusCodes.CANCELED -> {
                              Log.d(TAG, "One-tap dialog was closed.")
                              // Don't re-prompt the user.
                              showOneTapUI = false
                          }
                          CommonStatusCodes.NETWORK_ERROR -> {
                              Log.d(TAG, "One-tap encountered a network error.")
                              // Try again or just ignore.
                          }
                          else -> {
                              Log.d(TAG, "Couldn't get credential from result." +
                                  " (${e.localizedMessage})")
                          }
                      }
                  }
              }
          }
      }
      // ...
  }

Próximos pasos

Cuando un usuario completa el registro con One Tap, obtienes un token de ID de Google, que incluye información básica del perfil: la dirección de correo electrónico, el nombre completo y la URL de la foto de perfil del usuario. En muchas apps, esta información es suficiente para que puedas autenticar al usuario en el backend y crear una cuenta nueva.

Si necesitas información adicional para completar la creación de la cuenta, como la fecha de nacimiento del usuario, muéstrale un flujo de detalles de registro en el que solicites esta información adicional. Luego, envíala a tu backend para completar la creación de la cuenta.