Inicie a vinculação da Conta do Google diretamente na sua plataforma.

A vinculação de contas pode ser feita diretamente no app para dispositivos móveis, permitindo que os usuários vinculem a conta no serviço à Conta do Google. O link estabelecido concede ao Google acesso aos dados que o usuário consente em compartilhar.

Observação: o link da sua plataforma só está disponível no Android. (em breve na Web)

Os benefícios para os usuários incluem:

• Os usuários podem iniciar e concluir o processo de vinculação de contas no seu app, um ambiente que já conhecem.
• Os usuários não precisam de credenciais de login porque já foram autenticados no dispositivo e no app para dispositivos móveis.

Os benefícios para desenvolvedores incluem:

• Controle onde promover e iniciar a vinculação de contas no seu app para dispositivos móveis, por exemplo, nas configurações do usuário, em intersticiais ou depois que um usuário faz login no app. Adicionar vários pontos de entrada para iniciar a vinculação de contas ajuda a tornar a vinculação de contas mais detectável, resultando em maior engajamento e número de contas vinculadas.
• Aumento da taxa de conversão, já que os usuários podem concluir o processo de vinculação em menos etapas do que no fluxo padrão do OAuth baseado na Web.
• É necessário pouco esforço de engenharia para implementar o link da sua plataforma (Android), porque esse fluxo aproveita sua implementação atual do OAuth2.0, supondo que você já tenha uma implementada.
• As taxas de desistência foram reduzidas porque os usuários não precisam reinserir as credenciais de login e podem concluir o processo em menos etapas. As taxas de desistência podem chegar a 80% nos fluxos em que os usuários precisam entrar no recall e inserir as credenciais de login.

Como funciona

A vinculação da sua plataforma é concluída nas etapas a seguir:

1. O usuário clica ou ativa um gatilho de vinculação no app para dispositivos móveis.
2. O usuário seleciona a Conta do Google a ser vinculada.
   1. O usuário seleciona uma Conta do Google já existente no dispositivo para vincular ou faz login com uma nova conta.
3. O usuário recebe telas de consentimento hospedadas pelo Google e precisa concordar em continuar ou cancelar para interromper o processo de conexão.
4. O usuário recebe a tela de permissão e precisa concordar em continuar ou cancelar para interromper o processo de conexão.
5. A vinculação é estabelecida entre a conta do usuário no seu serviço e a Conta do Google.

Figura 1. Fluxo de vinculação da sua plataforma

Requisitos

Para implementar a vinculação da sua plataforma, você precisa do seguinte:

• Um app Android.
• Ter, gerenciar e manter um servidor OAuth 2.0 que ofereça suporte ao fluxo do código de autorização do OAuth 2.0.

Configuração

Antes de prosseguir com as etapas abaixo, você precisa concluir o processo de registro da vinculação de contas .

Configurar o ambiente de desenvolvimento

Instale a versão mais recente do Google Play Services no host de desenvolvimento:

1. Abra o SDK do Android Manager.

Observação: se esta for a primeira vez que você configura o ambiente de desenvolvimento do Android, revise e instale os pacotes recomendados do SDK do Android.

1. Em Ferramentas do SDK, encontre Google Play Services.

2. Se o status desses pacotes não for "Instalado", selecione os dois e clique em Install Packages.

Configurar o app

1. No arquivo build.gradle para envolvidos no projeto, inclua o repositório Maven do Google nas seções buildscript e allprojects.

   buildscript {
       repositories {
           google()
       }
   }
   
   allprojects {
       repositories {
           google()
       }
   }
   

2. Adicione as dependências da API "Link with Google" ao arquivo Gradle do módulo no nível do app, que geralmente é app/build.gradle:

   dependencies {
     implementation 'com.google.android.gms:play-services-auth:21.5.1'
   }
   

Adicionar suporte à vinculação da sua plataforma

O fluxo de vinculação da sua plataforma resulta em um token de acesso, fornecido pelo seu serviço, salvo pelo Google. O consentimento precisa ser recebido antes de retornar o token para o usuário.

Siga as etapas abaixo para receber o consentimento do usuário e retornar um token de código de autorização pelo SDK do Google Play Services.

1. Crie uma PendingIntent que possa iniciar sua atividade de consentimento. O consentimento é iniciado pela API Google Play Services. Você precisará fornecer um PendingIntent (que será chamado de consentPendingIntent para fins de esclarecimento) quando a API for chamada.

   Kotlin

   // Build a PendingIntent that can launch the consent activity
   val consentPendingIntent = buildConsentPendingIntent()
   

   Java

   // Build a PendingIntent that can launch your consent activity
   PendingIntent consentPendingIntent =
             buildConsentPendingIntent();
   

2. Crie uma atividade correspondente para processar a intent de consentimento.

   Kotlin

     class ConsentActivity : AppCompatActivity
   
     private fun onConsentAccepted() {
         // Obtain a token (for simplicity, we’ll ignore the async nature
         // of the following call)
         val token = getToken()
         val intent = Intent()
                     .putExtra(SaveAccountLinkingTokenRequest.EXTRA_TOKEN,
                               token)
         setResult(Activity.RESULT_OK, intent)
         finish()
     }
   
     private fun onConsentRejectedOrCanceled() {
         setResult(Activity.RESULT_CANCELED)
         finish()
     }
   

   Java

     public class ConsentActivity extends AppCompatActivity {
       ...
       private void onConsentAccepted() {
         // Obtain a token (for simplicity, we’ll ignore the async nature of
         // the following call
         String token = getToken();
         Intent intent = new Intent();
         intent.putExtra(SaveAccountLinkingTokenRequest.EXTRA_TOKEN, token);
         setResult(Activity.RESULT_OK, intent);
         finish();
       }
   
       private void onConsentRejectedOrCanceled() {
         setResult(Activity.RESULT_CANCELED, null);
         finish();
       }
    }
   
   

   Presumimos que os métodos onConsentAccpeted() e onConsentRejectedOrCanceled() são chamados se o usuário aceitar ou rejeitar/cancelar o consentimento, respectivamente.

3. Crie uma solicitação para salvar o token e, entre outros parâmetros de configuração, transmita a PendingIntent criada na etapa 1 acima.

   Kotlin

     // Create an ActivityResultLauncher which registers a callback for the
     // Activity result contract
     val activityResultLauncher = registerForActivityResult(
       ActivityResultContracts.StartIntentSenderForResult())
       { result ->
         if (result.resultCode == RESULT_OK) {
           // Successfully finished the flow and saved the token
         } else {
           // Flow failed, for example the user may have canceled the flow
         }
       }
   
     // Build token save request
     val request = SaveAccountLinkingTokenRequest.builder()
       .setTokenType(SaveAccountLinkingTokenRequest.TOKEN_TYPE_AUTH_CODE)
       .setConsentPendingIntent(consentPendingIntent)
       .setServiceId("service-id-of-and-defined-by-developer")
       //Set the scopes that the token is valid for on your platform
       .setScopes(scopes)
       .build()
   
      // Launch consent activity and retrieve token
      Identity.getCredentialSavingClient(this)
        .saveAccountLinkingToken(request)
        .addOnSuccessListener( saveAccountLinkingTokenResult -> {
           if (saveAccountLinkingTokenResult.hasResolution()) {
             val pendingIntent = saveAccountLinkingTokenResult
                                 .getPendingIntent()
             val intentSenderRequest = IntentSenderRequest
                                       .Builder(pendingIntent).build()
             activityResultLauncher.launch(intentSenderRequest)
           } else {
              // This should not happen, let’s log this
              Log.e(TAG, "Failed to save token");
           }
         })
         .addOnFailureListener(e -> Log.e(TAG, “Failed to save token”, e))
   

   Java

     // Create an ActivityResultLauncher which registers a callback for the
     // Activity result contract
     ActivityResultLauncher<IntentSenderRequest>
         activityResultLauncher =
         registerForActivityResult(new ActivityResultContracts
                                       .StartIntentSenderForResult(),
                                   result -> {
         if (result.getResultCode() == RESULT_OK) {
             // Successfully finished the flow and saved the token
         } else {
             // Flow failed, for example the user may have canceled the flow
         }
     });
   
    // Build token save request
    SaveAccountLinkingTokenRequest request =
       SaveAccountLinkingTokenRequest.builder()
           .setTokenType(
               SaveAccountLinkingTokenRequest.TOKEN_TYPE_AUTH_CODE)
           .setConsentPendingIntent(consentPendingIntent)
           .setServiceId("service-id-of-and-defined-by-developer")
           //Set the scopes that the token is valid for on your platform
           .setScopes(scopes)
           .build();
   
     // Launch consent activity and retrieve token
     Identity.getCredentialSavingClient(this)
         .saveAccountLinkingToken(request)
         .addOnSuccessListener(
             saveAccountLinkingTokenResult -> {
               if (saveAccountLinkingTokenResult.hasResolution()) {
                 // Launch the resolution intent
                 PendingIntent pendingIntent =
                     saveAccountLinkingTokenResult.getPendingIntent();
                 IntentSenderRequest intentSenderRequest =
                     new IntentSenderRequest.Builder(pendingIntent).build();
                 activityResultLauncher.launch(intentSenderRequest);
               } else {
                 // This should not happen, let’s log this
                 Log.e(TAG, "Failed to save token");
               }
             })
         .addOnFailureListener(e -> Log.e(TAG, "Failed to save token", e));
     ```
   

As etapas acima solicitam o consentimento de um usuário e retornam um código de autorização ao Google.

Práticas recomendadas

• O app precisa indicar o status da vinculação ao usuário por meio de um botão, alternância ou um elemento visual semelhante.

  

  Figura 1. Exemplo de imagem de status da vinculação

• Você precisa notificar o usuário após uma vinculação bem-sucedida, por exemplo, mostrar um aviso, acionar uma mudança de estado ou redirecionar o usuário para uma página de sucesso de vinculação separada.

• Considere pedir aos usuários no app para vincular contas, de preferência com base em indicadores fortes de que a vinculação beneficiaria esses usuários.

• Após a vinculação, mostre aos usuários um exemplo do que fazer com a conta vinculada. Por exemplo, se você acabou de vincular um serviço de streaming de música, peça ao Google Assistente para tocar música.

• Permita que os usuários gerenciem as contas vinculadas, incluindo a opção de desvinculá-las. Direcione-os para a página de gerenciamento de contas vinculadas do Google, ou seja, https://myaccount.google.com/accountlinking.

Referência

Documentação de referência da API de autenticação do Android