Crie novas contas com um toque

Se você oferece suporte para login com Contas do Google, use o cliente de login com um toque para oferecer aos usuários uma experiência de criação de conta sem atritos que nunca os tira do contexto do app.

Interface de inscrição com um toque

Quando você mostra a interface de um toque, os usuários são solicitados a criar uma nova conta no seu app usando uma das Contas do Google no dispositivo. Se o usuário escolher continuar, você receberá um token de ID com informações básicas do perfil, como nome, foto do perfil e endereço de e-mail verificado, que podem ser usados para criar a nova conta.

A implementação da criação de contas com um toque tem duas partes:

  • Integrar o cliente do One Tap ao seu app, conforme descrito nesta página. Isso é basicamente o mesmo que usar o login com um toque, mas com algumas diferenças na configuração.
  • Adicionar ao back-end a capacidade de criar contas de usuário com base em tokens de ID do Google, o que é discutido em Como usar tokens de ID no back-end.

Onde devo usar a inscrição com um toque?

O lugar mais eficaz para oferecer a inscrição com um toque aos usuários é em um contexto em que a inscrição ativa novos recursos. Primeiro, tente fazer login do usuário com uma credencial salva. Se nenhuma credencial salva for encontrada, ofereça a criação de uma nova conta para o usuário.

Antes de começar

Configure o projeto do console de APIs do Google e o projeto Android, conforme descrito em Primeiras etapas com o login com um toque.

1. Configurar o cliente de um toque

Para configurar o cliente do One Tap para a criação de contas, faça o seguinte:

  • Não ative as solicitações de credenciais de senha. A inscrição com um toque só é possível com a autenticação baseada em token.

  • Ative as solicitações de token de ID do Google usando setGoogleIdTokenRequestOptions() e estas configurações:

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. Acompanhar o cancelamento da interface do recurso "Login com um toque"

É preciso acompanhar se o usuário já recusou o uso da inscrição com um toque fechando o aviso ou tocando fora dele. Isso pode ser tão simples quanto uma propriedade booleana da sua atividade. Consulte Parar de mostrar a interface One Tap abaixo.

3. Mostrar a interface de inscrição com um toque

Se o usuário não tiver recusado o uso do recurso Um toque para criar uma nova conta, chame o método beginSignIn() do objeto cliente e anexe listeners ao Task que ele retorna. Os apps geralmente fazem essa etapa quando uma solicitação de login com um toque não encontra nenhuma credencial salva, ou seja, no listener de falha da solicitação de login.

O cliente de um toque vai chamar o listener de sucesso se o usuário tiver uma ou mais Contas do Google configuradas no dispositivo. No listener de sucesso, receba a intent pendente do resultado Task e transmita-a para startIntentSenderForResult() para iniciar a interface de um toque.

Se o usuário não tiver nenhuma Conta do Google no dispositivo, o cliente do One Tap vai chamar o listener de falha. Nesse caso, nenhuma ação é necessária: basta continuar apresentando a experiência de desativação do app, e o usuário pode se inscrever com o fluxo normal de criação de conta.

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. Processar a resposta do usuário

A resposta do usuário ao comando de inscrição com um toque será informada ao app usando o método onActivityResult() da atividade. Se o usuário escolher criar uma conta, o resultado será um token de ID do Google. Se o usuário recusar o registro, fechando a interface do One Tap ou tocando fora dela, o resultado será retornado com o código RESULT_CANCELED. Seu app precisa lidar com as duas possibilidades.

Criar uma conta com um token de ID do Google

Se o usuário optar por se inscrever com uma Conta do Google, será possível receber um token de ID para ele transmitindo os dados de intent de onActivityResult() para o método getSignInCredentialFromIntent() do cliente do One Tap. A credencial terá uma propriedade googleIdToken não nula.

Use o token de ID para criar uma conta no seu back-end (consulte Autenticar com um back-end usando tokens de ID) e fazer login do usuário.

A credencial também contém todos os outros detalhes que você solicitou, como o número de telefone verificado da conta, se disponível.

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) {
                    // ...
            }
        }
    }
    // ...
}

Parar de mostrar a interface do One Tap

Se o usuário recusar o login, a chamada para getSignInCredentialFromIntent() vai gerar um ApiException com um código de status CommonStatusCodes.CANCELED. Quando isso acontecer, pare temporariamente de mostrar a interface de login de um toque para não incomodar os usuários com solicitações repetidas. O exemplo abaixo faz isso definindo uma propriedade na atividade, que é usada para determinar se o login com um toque é oferecido ao usuário. No entanto, também é possível salvar um valor para SharedPreferences ou usar outro método.

É importante implementar sua própria limitação de taxa de solicitações de login com um toque. Se você não fizer isso e um usuário cancelar várias solicitações seguidas, o cliente do One Tap não vai solicitar a ele nas 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óximas etapas

Quando um usuário conclui o fluxo de inscrição com um toque, você recebe um token de ID do Google, que inclui algumas informações básicas do perfil: endereço de e-mail, nome completo e URL da foto do perfil do usuário. Para muitos apps, essas informações são suficientes para autenticar o usuário no back-end e criar uma nova conta.

Se você precisar de mais informações para concluir a criação da conta, por exemplo, a data de nascimento do usuário, mostre ao usuário um fluxo de detalhes de inscrição em que você solicite essas informações. Em seguida, envie-as para o back-end para concluir a criação da conta.