Crea cuentas nuevas con un solo toque

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

IU de registro con un solo toque

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 en su dispositivo. Si el usuario elige 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 tiene dos partes:

  • Integrar el cliente de One Tap en tu app, que se describe en esta página. Esto es casi lo mismo que usar el 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, que se analiza en Cómo usar 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 habilitaría 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 APIs de Google y tu proyecto de Android como se describe en Cómo comenzar 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 esta 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. Haz un seguimiento de la cancelación de la IU de One Tap

Debes hacer un seguimiento para saber si el usuario ya rechazó usar el registro con One Tap cerrando la solicitud o presionando fuera de ella. Esto puede ser tan simple como una propiedad booleana de tu Activity. (Consulta Deja de mostrar la IU de One Tap UI, a continuación).

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 muestra. Por lo general, las apps realizan este paso cuando una solicitud de acceso con One Tap no encuentra credenciales guardadas, es decir, en el objeto de escucha de errores de la solicitud de acceso.

El cliente de One Tap llamará al objeto de escucha 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 Task y pásalo a startIntentSenderForResult() para iniciar la IU de One Tap.

Si el usuario no tiene ninguna Cuenta de Google en el dispositivo, el cliente de One Tap llamará al objeto de escucha de errores. En este caso, no es necesario realizar ninguna acción: puedes seguir presentando la experiencia de la app sin acceso, y el usuario puede registrarse con el 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. Controla la respuesta del usuario

La respuesta del usuario a la solicitud 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 mostrará 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 cualquier detalle adicional 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) {
                    // ...
            }
        }
    }
    // ...
}

Deja 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 solicitudes repetidas. En el siguiente ejemplo, se logra esto configurando una propiedad en la Activity, que se usa para determinar si se le ofrece 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 implementar tu propia limitación de frecuencia de las solicitudes de acceso con One Tap. Si no lo haces y un usuario cancela varias solicitudes seguidas, el cliente de One Tap no le solicitará al usuario que acceda 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 flujo de 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. Para muchas apps, esta información es suficiente para autenticar al usuario en el backend y crear una cuenta nueva.

Si necesitas información adicional para completar la creación de la cuenta (por ejemplo, la fecha de nacimiento del usuario), preséntale al usuario un flujo de detalles de registro, en el que le solicites esta información adicional. Luego, envíala a tu backend para completar la creación de la cuenta.