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 o desempenho da vinculação de contas, envolvendo os usuários no contexto conhecido do app em vez de uma conversa do Google Assistente. Ele pode ser integrado à integração do usuário, configurações e outras superfícies do app, criando oportunidades de descoberta e engajamento da ação do Google Assistente. Por exemplo, após a vinculação, você pode se oferecer para levar o usuário diretamente à sua ação.

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 / alternar um acionador de vinculação no seu 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 existente 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 em continuar ou cancelar para interromper o processo de vinculação.
4. A tela de consentimento é mostrada ao usuário e precisa concordar em 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.
• Tenha, gerencie e mantenha um servidor OAuth 2.0 compatível com o 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 seu host de desenvolvimento:

1. Abra o Android SDK Manager.

.

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

1. Em SDK Tools, localize Google Play Services.

2. Se o status desses pacotes não for "Instalado", selecione-os 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 "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.2.0'
   }
   

Adicionar suporte para o Link na sua plataforma

A vinculação do fluxo da Plataforma resultará em um token de acesso, fornecido pelo seu serviço, sendo salvo pelo Google. É necessário receber consentimento 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 com o SDK do Google Play Services.

1. Criar um PendingIntent que possa iniciar sua atividade de consentimento: o consentimento é iniciado pela API Play Services. Será necessário fornecer um PendingIntent (referido como consentPendingIntent para maior clareza) 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 intenção 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 seu 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 deve indicar o status do link ao usuário por meio de um botão, de ativação ou de um elemento visual semelhante.

  

  Figura 1. Exemplo de imagem de status do link

• Você deve notificar o usuário depois de uma vinculação bem-sucedida, por exemplo, exibir um aviso, acionar uma mudança de estado de alternância ou redirecionar o usuário para uma página separada de conclusão de link.

• Solicite que os usuários no app vinculem contas, de preferência com base em fortes sinais de que a vinculação seria vantajosa para eles.

• Após a vinculação, 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 desvinculá-las. Direcione o usuário 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 Android auth