Crie novas contas com um toque

Se você oferece suporte ao login com Contas do Google, use o login com um toque também proporcionem aos usuários uma experiência de criação de conta simples que nunca os tira do contexto do seu app.

Interface de inscrição com um toque

Quando você exibe a interface de um toque, os usuários precisam criar uma nova conta com seu aplicativo usando uma das Contas do Google em seu dispositivo. Se o usuário escolher para continuar, você recebe um token de ID com informações básicas de perfil: nome, foto do perfil e endereço de e-mail verificado, que você pode usar para crie 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, descrito nesta página. Isso é basicamente o mesmo que usar o login com um toque, mas com algumas diferenças configuração do Terraform.
  • Adicionar ao back-end a capacidade de criar contas de usuário usando o ID do Google Isso é abordado em Como usar tokens de ID no back-end.

Onde devo usar a assinatura com um toque?

O lugar de maior impacto para oferecer a assinatura com um toque aos usuários é em um contexto em que fazer login ativaria novos recursos. Primeiro, tente fazer o login do usuário com uma credencial salva. Se nenhuma credencial salva for encontrada, ofereça a opção de criar uma nova para o usuário.

Antes de começar

Configure seu projeto do console de APIs do Google e projeto Android conforme descrito em Comece a usar o login com um toque.

1. Configurar o cliente de um toque

Para configurar o cliente de um toque para a criação da conta, faça o seguinte:

  • Não ative solicitações de credenciais de senha. A inscrição com um toque só é possível com 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. Acompanhe o cancelamento da interface com um toque

Verifique se o usuário já recusou o uso com um toque. se inscreva ao fechar a solicitação ou tocar fora dela. Pode ser simples como uma propriedade booleana da atividade. Consulte Parar de exibir o recurso 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 de um toque para criar uma nova conta, chame o método método beginSignIn() do objeto do cliente e anexar listeners ao Task retorna. Os apps geralmente realizam essa etapa quando uma solicitação de login com um toque não é encontrada todas as credenciais salvas, ou seja, no listener de falha da interface de login solicitação.

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

Se o usuário não tiver nenhuma Conta do Google no dispositivo, o cliente de um toque chamará o listener de falha. Nesse caso, nenhuma ação é necessária. Você pode continue apresentando a experiência do app sem fazer login, e o usuário poderá inscreva-se com seu 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 à solicitação de inscrição com um toque será enviada ao app usando o método onActivityResult() da atividade. Se o usuário tiver optado por criar o resultado será um token de ID do Google. Se o usuário não se inscrever, seja fechando ou tocando fora da interface de um toque, o resultado retornará pelo 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 tiver optado por 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 recurso de um toque método getSignInCredentialFromIntent() do cliente. A credencial terá um 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 faça o login do usuário.

A credencial também contém 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 de um toque

Se o usuário tiver recusado 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 solicitações repetidas. O exemplo a seguir faz isso definindo uma propriedade na Activity, que ela usa para determinar se é necessário oferecer ao usuário o login com um toque; No entanto, também é possível salve um valor em SharedPreferences ou use algum outro método.

É importante implementar sua própria limitação de taxa das 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 de um toque não solicitará ao usuário as 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 de perfil: o endereço de e-mail do usuário, nome completo, e o URL da foto do perfil. 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, como a data de nascimento do usuário: apresente a ele um fluxo de detalhes da inscrição, em que solicitar essas informações adicionais. Em seguida, envie-o ao back-end para concluir a criação da conta.