Se você tem 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 contas simples que nunca os tira do contexto do seu app.
Quando você exibe a interface de um toque, os usuários recebem uma solicitação para criar uma nova conta com seu app usando uma das Contas do Google no dispositivo deles. Se o usuário quiser continuar, você receberá um token de ID com informações básicas de perfil, como 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, que é 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 a partir de tokens de ID do Google, assunto que é discutido 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 opção de criar uma nova conta para o usuário.
Antes de começar
Configure o projeto do Console de APIs do Google e o projeto Android como descrito em Primeiras etapas com o login com um toque.
1. Configurar o cliente de um toque
Para configurar o cliente de um toque para criação de conta, 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:- Defina o ID do cliente do servidor como o ID criado no console de APIs do Google. Esse é o ID do cliente do seu servidor, não do Android.
- Configure o cliente para mostrar todas as Contas do Google no dispositivo, ou seja, não filtre por contas autorizadas.
- Também é possível solicitar o número de telefone verificado da conta.
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
Você precisa fechar a solicitação ou tocar fora dela para verificar se o usuário já recusou a inscrição. Isso pode ser tão simples quanto uma propriedade booleana da sua atividade. Consulte Parar de exibir a interface de um toque abaixo.
3. Exibir a interface de inscrição com um toque
Se o usuário não tiver recusado o uso do recurso de um toque para criar uma nova conta, chame o
método beginSignIn() do objeto cliente e anexe listeners à Task
retornada. Os apps geralmente realizam essa etapa quando uma solicitação de login com um toque não encontra
credenciais salvas, ou seja, no listener de falha da solicitação
de login.
O cliente de um toque chamará o listener de êxito se o usuário tiver uma ou mais Contas do Google configuradas no dispositivo. No listener de êxito, acesse 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 uma Conta do Google no dispositivo, o cliente de um toque chamará o listener de falhas. Nesse caso, nenhuma ação é necessária: você pode simplesmente continuar apresentando a experiência sem login 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 à solicitação de inscrição com um toque será informada ao seu app
usando o método onActivityResult() da sua atividade. Se o usuário criar uma conta, o resultado será um token de ID do Google. Se o usuário se recusar a fazer a inscrição,
fechando a interface de um toque ou tocando fora dela, o resultado retornará
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 se inscrever com uma Conta do Google, você poderá receber um token de ID transmitindo os dados de intent do 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 faça o login do usuário.
A credencial também contém todos os detalhes adicionais 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 se recusar a fazer login, a chamada para getSignInCredentialFromIntent()
gerará uma ApiException com um código de status CommonStatusCodes.CANCELED.
Quando isso acontecer, interrompa temporariamente a exibição da 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 atividade, que ela usa para
determinar se é necessário oferecer ao usuário o login com um toque. 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 para as solicitações de login com um toque. Se você não fizer isso e o usuário cancelar várias solicitações seguidas, o cliente de um toque não vai enviar uma solicitação 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 ao usuário um fluxo de detalhes de inscrição, em que poderá solicitá-las. Em seguida, envie-as ao seu back-end para concluir a criação da conta.