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 pela sua plataforma é concluída nas seguintes etapas:

1. O usuário vai clicar / ativar um acionador de vinculação no seu app para dispositivos móveis.
2. O usuário seleciona a Conta do Google que quer 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ê uma tela de permissão hospedada pelo Google e precisa concordar para continuar ou cancelar para interromper o processo de vinculação.
4. A tela de permissão é mostrada ao usuário, que precisa concordar para continuar ou cancelar para interromper o processo de vinculação.
5. A vinculação é estabelecida 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 do 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 SDK Manager do Android.

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 Ferramentas do SDK, encontre o Google Play Services.

2. Se o status desses pacotes não for "Installed", 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:22.0.0'
   }
   

Adicionar suporte para o Link da sua plataforma

O fluxo de vinculação pela sua plataforma vai resultar em um token de acesso, fornecido pelo seu serviço, sendo 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 autenticaçã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ê vai 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. Criar 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();
       }
    }
   
   

   Vamos supor 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 solicitam o consentimento do usuário e retornam um código de autorização ao Google.

Práticas recomendadas

• Seu app precisa indicar o status da vinculação ao usuário usando um botão, uma chave ou um elemento visual semelhante.

  

  Figura 1. Imagem de exemplo do status do link

• Notifique o usuário após uma vinculação bem-sucedida, por exemplo, mostrando um aviso, acionando uma mudança de estado de alternância ou redirecionando o usuário para uma página separada de vinculação bem-sucedida.

• Considere pedir aos usuários no app que vinculem as contas, de preferência com base em indicadores fortes de que a vinculação seria benéfica para eles.

• Depois de vincular, 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 uma música.

• Permita que os usuários gerenciem as contas vinculadas, incluindo a opção de desvinculá-las. Oriente o usuário a acessar 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