Crie novas contas com um toque

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

Interface de inscrição com um toque

Ao mostrar 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 (nome, foto do perfil e endereço de e-mail verificado), que poderá ser usado para criar a nova conta.

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

  • Integrar o cliente de "Um toque" ao seu app, conforme descrito nesta página. Isso é quase igual ao uso do 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 tokens de ID do Google, que é discutida em Como usar tokens de ID no back-end.

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

O lugar mais impactante para oferecer a inscrição com um toque aos usuários é em um contexto em que o login ativaria 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 seu projeto do console de APIs do Google e o projeto do Android conforme descrito em Introdução ao login com um toque.

1. Configurar o cliente de "Um toque"

Para configurar o cliente de "Um toque" para a criação de contas, faça o seguinte:

  • Não ative 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 de "Um toque"

Você precisa acompanhar se o usuário já recusou o uso da inscrição com um toque fechando o prompt ou tocando fora dele. Isso pode ser tão simples quanto uma propriedade booleana da sua atividade. (Consulte Parar de mostrar a interface de "Um toque" UI 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 do cliente e anexe listeners à 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 da Task e transmita-a para startIntentSenderForResult() para iniciar a interface de "Um toque".

Se o usuário não tiver Contas do Google no dispositivo, o cliente de "Um toque" vai chamar o listener de falha. Nesse caso, nenhuma ação é necessária: você pode simplesmente continuar apresentando a experiência desconectada do app, e o usuário pode se inscrever com o fluxo normal de criação de contas.

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 prompt de inscrição com um toque será informada ao seu 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 a inscrição, fechando a interface de "Um toque" ou tocando fora dela, o resultado será retornado com o código RESULT_CANCELED. Seu app precisa processar as duas possibilidades.

Criar uma conta com um token de ID do Google

Se o usuário escolher se inscrever com uma Conta do Google, você poderá receber um token de ID para o usuário transmitindo os dados da intent de onActivityResult() para o método getSignInCredentialFromIntent() do cliente de "Um toque". A credencial terá uma propriedade googleIdToken não nula.

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

A credencial também contém outros detalhes solicitados, 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 de "Um toque"

Se o usuário recusar o login, a chamada para getSignInCredentialFromIntent() vai gerar uma ApiException com um código de status CommonStatusCodes.CANCELED. Quando isso acontecer, pare temporariamente de mostrar a interface de login com um toque para não incomodar os usuários com prompts repetidos. O exemplo a seguir realiza essa ação definindo uma propriedade na atividade, que é usada para determinar se o login com um toque deve ser oferecido ao usuário. No entanto, você também pode salvar um valor em SharedPreferences ou usar outro método.

É importante implementar sua própria limitação de taxa de prompts de login com um toque. Se você não fizer isso e um usuário cancelar vários prompts seguidos, o cliente de "Um toque" não vai mostrar o prompt ao usuário 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 você 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, apresente um fluxo de detalhes de inscrição, em que você solicita essas informações adicionais. Em seguida, envie-as ao back-end para concluir a criação da conta.