Aviso: esses dados são fornecidos de acordo com a Política de dados do usuário do Google . Reveja e cumpra a política. Não fazer isso pode resultar na suspensão do projeto ou suspensão da conta.

Faça login dos usuários com suas credenciais salvas

Use o cliente de login One Tap para solicitar permissão do usuário para recuperar uma das credenciais que ele usou anteriormente para fazer login em seu aplicativo. Essas credenciais podem ser uma Conta do Google ou uma combinação de nome de usuário e senha salvas com o Google usando o Chrome, preenchimento automático do Android ou Smart Lock para senhas.

IU de login com um toque

Quando as credenciais são recuperadas com êxito, você pode usá-las para conectar o usuário sem problemas ao seu aplicativo.

Se o usuário não salvou nenhuma credencial, nenhuma IU é apresentada e você pode fornecer sua experiência normal de desconexão.

Onde devo usar o login do One Tap?

Se o seu aplicativo exigir que os usuários façam login, exiba a IU do One Tap na tela de login. Isso pode ser útil mesmo se você já tiver um botão "Fazer login com o Google": como a IU do One Tap pode ser configurada para mostrar apenas as credenciais que o usuário usou anteriormente para fazer login, pode ser um lembrete para os usuários que fazem login com pouca frequência como eles fizeram login da última vez e evite que eles criem acidentalmente novas contas com seu aplicativo.

Se o login for opcional para seu aplicativo, considere usar o login One Tap em qualquer tela que tenha uma experiência aprimorada de login. Por exemplo, se os usuários podem navegar pelo conteúdo com seu aplicativo enquanto estão desconectados, mas só podem postar comentários ou adicionar itens a um carrinho de compras após o login, esse seria um contexto sensato para o login do One Tap.

Aplicativos opcionais de login também devem usar o login do One Tap em suas telas de login, pelos motivos declarados acima.

Antes de você começar

1. Configure o cliente de login One Tap

Você pode configurar o cliente de login do One Tap para fazer o login dos usuários com senhas salvas, Contas do Google salvas ou qualquer um dos dois. (Recomenda-se o suporte a ambos, para permitir a criação de conta com um toque para novos usuários e login automático ou com um toque para o maior número possível de usuários recorrentes.)

Se os seus usos de aplicativos sign-in-base senha, utilize setPasswordRequestOptions() para permitir senha solicitações de credenciais.

Se o seu aplicativo usa o Google Sign-in, uso setGoogleIdTokenRequestOptions() para ativar e configurar o Google ID solicitações de token:

  • Defina o ID do cliente do servidor para o ID que você criou no console de APIs do Google . Observe que este é o ID do cliente do seu servidor, não o ID do cliente Android.

  • Configure o cliente para filtrar por contas autorizadas. Quando você ativa esta opção, o cliente One Tap só solicita que os usuários façam login em seu aplicativo com contas do Google que já usaram no passado. Isso pode ajudar os usuários a fazer login com êxito quando não têm certeza se já têm uma conta ou qual Conta do Google usaram, e impede que os usuários criem acidentalmente novas contas com seu aplicativo.

  • Se você quiser se inscrever usuários automaticamente quando possível, ativar o recurso com setAutoSelectEnabled() . O login automático é possível quando os seguintes critérios são atendidos:

    • O usuário tem exatamente uma credencial salva para o seu aplicativo. Ou seja, uma senha salva ou uma Conta do Google salva.
    • O usuário não tenha desativado entrada automática em suas configurações da Conta do Google .
  • Embora opcional, recomendamos que você considere fortemente o uso de um nonce para melhorar a segurança de login e evitar ataques de repetição. Use setNonce para incluir um nonce em cada solicitação. Veja SafetyNet é Obter um nonce seção para sugestões e detalhes adicionais sobre a geração de um nonce.

Java

public class YourActivity extends AppCompatActivity {
  // ...

  private SignInClient oneTapClient;
  private BeginSignInRequest signInRequest;

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

      oneTapClient = Identity.getSignInClient(this);
      signInRequest = BeginSignInRequest.builder()
              .setPasswordRequestOptions(PasswordRequestOptions.builder()
                      .setSupported(true)
                      .build())
              .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
                      .setSupported(true)
                      // Your server's client ID, not your Android client ID.
                      .setServerClientId(getString(R.string.default_web_client_id))
                      // Only show accounts previously used to sign in.
                      .setFilterByAuthorizedAccounts(true)
                      .build())
              // Automatically sign in when exactly one credential is retrieved.
              .setAutoSelectEnabled(true)
              .build();
      // ...
  }
  // ...
}

Kotlin

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

    private lateinit var oneTapClient: SignInClient
    private lateinit var signInRequest: BeginSignInRequest

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

        oneTapClient = Identity.getSignInClient(this)
        signInRequest = BeginSignInRequest.builder()
            .setPasswordRequestOptions(BeginSignInRequest.PasswordRequestOptions.builder()
                .setSupported(true)
                .build())
            .setGoogleIdTokenRequestOptions(
                BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                    .setSupported(true)
                    // Your server's client ID, not your Android client ID.
                    .setServerClientId(getString(R.string.your_web_client_id))
                    // Only show accounts previously used to sign in.
                    .setFilterByAuthorizedAccounts(true)
                    .build())
            // Automatically sign in when exactly one credential is retrieved.
            .setAutoSelectEnabled(true)
            .build()
        // ...
    }
    // ...
}

2. Verifique se há um usuário conectado

Se sua atividade puder ser usada por um usuário conectado ou desconectado, verifique o status do usuário antes de exibir a IU de login do One Tap.

Você também deve acompanhar se o usuário já recusou o uso do One Tap, fechando o prompt ou tocando fora dele. Isso pode ser tão simples quanto uma propriedade booleana de sua atividade. (Veja parar de exibir a Um Toque UI , abaixo).

3. Exibir a IU de login do One Tap

Se o usuário não está conectado e não já se recusou a usar Um Toque sign-in, ligue para o objeto cliente beginSignIn() método, e anexar ouvintes para a Task ele retorna. Aplicativos normalmente faz isso na sua actividade onCreate() método ou após transições de tela quando se utiliza uma arquitetura única atividade.

O cliente One Tap chamará o ouvinte de sucesso se o usuário tiver alguma credencial salva para o seu aplicativo. No ouvinte sucesso, obter a intenção pendentes da Task resultado e passá-lo para startIntentSenderForResult() para iniciar o sign-in One Tap UI.

Se o usuário não tiver nenhuma credencial salva, o cliente One Tap chamará o ouvinte de falha. Nesse caso, nenhuma ação é necessária: você pode simplesmente continuar apresentando a experiência desconectada do aplicativo. No entanto, se você oferece suporte à inscrição One Tap, pode iniciar esse fluxo aqui para uma experiência de criação de conta perfeita. Veja Criar novas contas com um simples toque .

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 saved credentials found. Launch the One Tap sign-up flow, or
                // do nothing and continue presenting the signed-out UI.
                Log.d(TAG, e.getLocalizedMessage());
            }
        });

Kotlin

oneTapClient.beginSignIn(signInRequest)
    .addOnSuccessListener(this) { result ->
        try {
            startIntentSenderForResult(
                result.pendingIntent.intentSender, REQ_ONE_TAP,
                null, 0, 0, 0, null)
        } catch (e: IntentSender.SendIntentException) {
            Log.e(TAG, "Couldn't start One Tap UI: ${e.localizedMessage}")
        }
    }
    .addOnFailureListener(this) { e ->
        // No saved credentials found. Launch the One Tap sign-up flow, or
        // do nothing and continue presenting the signed-out UI.
        Log.d(TAG, e.localizedMessage)
    }

4. Lidar com a resposta do usuário

A resposta do usuário à Um sinal-in Tap alerta será relatado ao seu aplicativo usando do seu Activity onActivityResult() método. Se o usuário escolheu entrar, o resultado será uma credencial salva. Se o usuário se recusou a entrar, quer fechando a Um Toque UI ou tocando fora dele, o resultado vai voltar com o código RESULT_CANCELED . Seu aplicativo precisa lidar com as duas possibilidades.

Faça login com as credenciais recuperadas

Se o usuário escolheu a credenciais compartilhar com seu aplicativo, você pode recuperá-los, passando os dados intenção de onActivityResult() para o cliente Um Toque getSignInCredentialFromIntent() método. A credencial terá um não-nulo googleIdToken propriedade, se o usuário compartilhou uma credencial Conta do Google com a sua aplicação, ou um não-nula password propriedade, se o usuário compartilhou uma senha salva.

Use a credencial para autenticar com o back-end do seu aplicativo.

  • Se um par de nome de usuário e senha foi recuperado, use-os para fazer login da mesma forma que faria se o usuário os tivesse fornecido manualmente.
  • Se as credenciais da Conta do Google foram recuperadas, use o token de ID para autenticar com seu back-end. Se você optou por usar um nonce para ajudar a evitar ataques de repetição, verifique o valor da resposta em seu servidor de back-end. Veja autenticar com um backend usando tokens de identificação .

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();
                  String username = credential.getId();
                  String password = credential.getPassword();
                  if (idToken !=  null) {
                      // Got an ID token from Google. Use it to authenticate
                      // with your backend.
                      Log.d(TAG, "Got ID token.");
                  } else if (password != null) {
                      // Got a saved username and password. Use them to authenticate
                      // with your backend.
                      Log.d(TAG, "Got password.");
                  }
              } 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
                    val username = credential.id
                    val password = credential.password
                    when {
                        idToken != null -> {
                            // Got an ID token from Google. Use it to authenticate
                            // with your backend.
                            Log.d(TAG, "Got ID token.")
                        }
                        password != null -> {
                            // Got a saved username and password. Use them to authenticate
                            // with your backend.
                            Log.d(TAG, "Got password.")
                        }
                        else -> {
                            // Shouldn't happen.
                            Log.d(TAG, "No ID token or password!")
                        }
                    }
                } catch (e: ApiException) {
                    // ...
                }
            }
        }
    }
    // ...
}

Parar de exibir a IU do One Tap

Se o usuário se recusou a entrar, a chamada para getSignInCredentialFromIntent() irá lançar uma ApiException com um CommonStatusCodes.CANCELED código de status. Quando isso acontecer, você deve desativar temporariamente a IU de login do One Tap para não incomodar seus usuários com solicitações repetidas. O exemplo a seguir faz isso definindo uma propriedade na Activity, que é usada para determinar se deve oferecer ao usuário a entrada One Tap; no entanto, você também pode salvar um valor a SharedPreferences ou usar algum outro método.

É importante implementar sua própria limitação de taxa de prompts de login do One Tap. Do contrário, e um usuário cancela vários prompts em uma linha, o cliente One Tap não solicitará o 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})")
                        }
                    }
                }
            }
        }
    }
    // ...
}

5. Lidar com a desconexão

Quando um usuário assina fora do seu aplicativo, chamar o cliente Um Toque signOut() método. Chamando signOut() desativa entrada automática até que o usuário se novamente.

Mesmo se você não usar o login automático, esta etapa é importante porque garante que, quando os usuários saem do seu aplicativo, o estado de autenticação de quaisquer APIs do Play Services que você usa também seja redefinido.

Próximos passos

Se você configurou o cliente One Tap para recuperar credenciais do Google, seu aplicativo agora pode obter tokens de ID do Google que representam as contas do Google de seus usuários. Saiba como você pode usar esses tokens no backend .

Se você apoiar Google Sign-in, você também pode usar o cliente Um Toque para adicionar a criação de contas sem atrito flui para a sua aplicação .