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)

Essa abordagem melhora a performance da vinculação de contas ao envolver os usuários no contexto familiar do seu app, em vez de uma conversa com o Google Assistente. Ele pode ser integrado à integração de usuários, às configurações e a outras plataformas do app, criando oportunidades para descoberta e engajamento da sua ação do Google Assistente. Por exemplo, depois de vincular, você pode oferecer ao usuário a opção de acessar sua ação diretamente.

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 seguintes etapas:

1. O usuário vai clicar / ativar um gatilho de vinculação no seu app para dispositivos móveis.
2. O usuário seleciona a Conta do Google para vincular.
   1. O usuário seleciona uma Conta do Google no dispositivo para vincular ou faz login com uma nova conta.
3. O usuário vê telas de consentimento hospedadas pelo Google e precisa concordar para continuar ou cancelar para interromper o processo de vinculação.
4. A tela de consentimento é mostrada ao usuário, que precisa concordar para continuar ou cancelar para interromper o processo de vinculação.
5. O link é estabelecido entre a conta do usuário no seu serviço e a Conta do Google dele.

Figura 1. Link do fluxo da plataforma

Requisitos

Para implementar o Link na sua plataforma, você precisa do seguinte:

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

Configuração

Antes de seguir as etapas abaixo, conclua 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 Android SDK Manager.

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

1. Em SDK Tools, encontre Google Play Services.

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

Configurar o app

1. No arquivo build.gradle no nível do 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 "Vincular com o Google" ao arquivo Gradle no nível do app do seu módulo, que geralmente é app/build.gradle:

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

Adicionar suporte para o Link na sua plataforma

O fluxo de vinculação da sua plataforma vai resultar em um token de acesso, fornecido pelo seu serviço, que será 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 a atividade de consentimento. O consentimento é iniciado pela API do Google Play Services. Você precisará fornecer um PendingIntent (que será chamado de consentPendingIntent para facilitar o entendimento) 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 a 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() sejam 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 o PendingIntent criado 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 pedem o consentimento do usuário e retornam um código de autorização ao Google.

Práticas recomendadas

• O app precisa indicar o status do link ao usuário com um botão, uma chave ou um elemento visual semelhante.

  

  Figura 1. Exemplo de imagem do status do link

• Notifique o usuário após uma vinculação bem-sucedida. Por exemplo, mostre uma mensagem temporária, acione uma mudança de estado de alternância ou redirecione o usuário para uma página separada de sucesso da vinculação.

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

• Depois de vincular com sucesso, dê 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.

• Permitir que os usuários gerenciem as contas vinculadas, incluindo a opção de desvincular. Indique a página de gerenciamento de Contas do Google vinculadas, ou seja, https://myaccount.google.com/accountlinking.

Referência

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