Esta página foi traduzida pela API Cloud Translation.

Login de conta vinculada para Android

O login da conta vinculada ativa o Login com um toque com o Google para usuários que já têm a Conta do Google vinculada ao seu serviço. Isso melhora a experiência dos usuários, porque eles podem fazer login com um clique, sem digitar novamente o nome de usuário e a senha. Isso também reduz as chances de os usuários criarem contas duplicadas no seu serviço.

O login da conta vinculada está disponível como parte do fluxo de login com um toque para Android. Isso significa que você não precisa importar uma biblioteca separada se o app já tem o recurso de um toque ativado.

Neste documento, você vai aprender a modificar seu app Android para oferecer suporte ao login de conta vinculada.

Como funciona

Você aceita mostrar as contas vinculadas durante o fluxo de login com um toque.
Se o usuário estiver conectado ao Google e vinculado a Conta do Google à conta dele no serviço, um token de ID será retornado para a conta vinculada.
O usuário verá uma solicitação de login com um toque com uma opção para fazer login no seu serviço com a conta vinculada.
Se o usuário optar por continuar com a conta vinculada, o token de ID do usuário será retornado ao app. Você faz a correspondência dele com o token enviado ao servidor na etapa 2 para identificar o usuário conectado.

Instalação

Configurar o ambiente de desenvolvimento

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

Abra o Android SDK Manager.

Em SDK Tools, encontre Google Play Services.
Se o status desses pacotes não estiver instalado, selecione-os e clique em Install Packages.

Configurar o app

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()
    }
}

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.0.0'
}
```

Modificar seu app Android para oferecer suporte ao login de conta vinculada

No final do fluxo de login da conta vinculada, um token de ID é retornado ao app. A integridade do token de ID precisa ser verificada antes do login do usuário.

O exemplo de código a seguir detalha as etapas a serem recuperadas, verificar o token de ID e, em seguida, fazer o login do usuário.

Criar uma atividade para receber o resultado da intent de login

Kotlin

  private val activityResultLauncher = registerForActivityResult(
    ActivityResultContracts.StartIntentSenderForResult()) { result ->
    if (result.resultCode == RESULT_OK) {
      try {
        val signInCredentials = Identity.signInClient(this)
                                .signInCredentialFromIntent(result.data)
        // Review the Verify the integrity of the ID token section for
        // details on how to verify the ID token
        verifyIdToken(signInCredential.googleIdToken)
      } catch (e: ApiException) {
        Log.e(TAG, "Sign-in failed with error code:", e)
      }
    } else {
      Log.e(TAG, "Sign-in failed")
    }
  }

Java

  private final ActivityResultLauncher<IntentSenderResult>
    activityResultLauncher = registerForActivityResult(
    new ActivityResultContracts.StartIntentSenderForResult(),
    result -> {
    If (result.getResultCode() == RESULT_OK) {
        try {
          SignInCredential signInCredential = Identity.getSignInClient(this)
                         .getSignInCredentialFromIntent(result.getData());
          verifyIdToken(signInCredential.getGoogleIdToken());
        } catch (e: ApiException ) {
          Log.e(TAG, "Sign-in failed with error:", e)
        }
    } else {
        Log.e(TAG, "Sign-in failed")
    }
});

Criar a solicitação de login

Kotlin

private val tokenRequestOptions =
GoogleIdTokenRequestOptions.Builder()
  .supported(true)
  // Your server's client ID, not your Android client ID.
  .serverClientId(getString("your-server-client-id")
  .filterByAuthorizedAccounts(true)
  .associateLinkedAccounts("service-id-of-and-defined-by-developer",
                           scopes)
  .build()

Java

 private final GoogleIdTokenRequestOptions tokenRequestOptions =
     GoogleIdTokenRequestOptions.Builder()
  .setSupported(true)
  .setServerClientId("your-service-client-id")
  .setFilterByAuthorizedAccounts(true)
  .associateLinkedAccounts("service-id-of-and-defined-by-developer",
                            scopes)
  .build()

Iniciar a intent pendente de login

Kotlin

 Identity.signInClient(this)
    .beginSignIn(
  BeginSignInRequest.Builder()
    .googleIdTokenRequestOptions(tokenRequestOptions)
  .build())
    .addOnSuccessListener{result ->
      activityResultLauncher.launch(result.pendingIntent.intentSender)
  }
  .addOnFailureListener {e ->
    Log.e(TAG, "Sign-in failed because:", e)
  }

Java

 Identity.getSignInClient(this)
  .beginSignIn(
    BeginSignInRequest.Builder()
      .setGoogleIdTokenRequestOptions(tokenRequestOptions)
      .build())
  .addOnSuccessListener(result -> {
    activityResultLauncher.launch(
        result.getPendingIntent().getIntentSender());
})
.addOnFailureListener(e -> {
  Log.e(TAG, "Sign-in failed because:", e);
});

Verificar a integridade do token de ID

Para verificar se o token é válido, verifique se os critérios a seguir foram atendidos:

O token de ID é assinado corretamente pelo Google. Use as chaves públicas do Google (disponíveis no formato JWK ou PEM) para verificar a assinatura do token. Essas chaves são alternadas regularmente. Examine o cabeçalho Cache-Control na resposta para determinar quando é preciso recuperá-las novamente.
O valor de aud no token de ID é igual a um dos IDs do cliente do seu app. Essa verificação é necessária para evitar que tokens de ID emitidos para um app malicioso seja usado para acessar dados sobre o mesmo usuário no servidor de back-end do app.
O valor de iss no token de ID é igual a accounts.google.com ou https://accounts.google.com.
O prazo de validade (exp) do token de ID não passou.
Se você precisar validar se o token de ID representa uma conta de organização do Google Workspace ou do Cloud, verifique a declaração hd, que indica o domínio hospedado do usuário. Precisa ser usado para restringir o acesso a um recurso apenas a membros de determinados domínios. A ausência dessa declaração indica que a conta não pertence a um domínio hospedado pelo Google.

Em vez de escrever seu próprio código para realizar essas etapas de verificação, é altamente recomendável usar uma biblioteca de cliente da API do Google para sua plataforma ou uma biblioteca JWT de uso geral. Para desenvolvimento e depuração, é possível chamar nosso endpoint de validação tokeninfo.

Usar uma biblioteca de cliente das APIs do Google

Usar a biblioteca de cliente das APIs do Google para Java é a maneira recomendada de validar tokens de ID do Google em um ambiente de produção.

Java

  import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken;
  import com.google.api.client.googleapis.auth.oauth2.GoogleIdToken.Payload;
  import com.google.api.client.googleapis.auth.oauth2.GoogleIdTokenVerifier;

  ...

  GoogleIdTokenVerifier verifier = new GoogleIdTokenVerifier.Builder(transport, jsonFactory)
      // Specify the CLIENT_ID of the app that accesses the backend:
      .setAudience(Collections.singletonList(CLIENT_ID))
      // Or, if multiple clients access the backend:
      //.setAudience(Arrays.asList(CLIENT_ID_1, CLIENT_ID_2, CLIENT_ID_3))
      .build();

  // (Receive idTokenString by HTTPS POST)

  GoogleIdToken idToken = verifier.verify(idTokenString);
  if (idToken != null) {
    Payload payload = idToken.getPayload();

    // Print user identifier
    String userId = payload.getSubject();
    System.out.println("User ID: " + userId);

    // Get profile information from payload
    String email = payload.getEmail();
    boolean emailVerified = Boolean.valueOf(payload.getEmailVerified());
    String name = (String) payload.get("name");
    String pictureUrl = (String) payload.get("picture");
    String locale = (String) payload.get("locale");
    String familyName = (String) payload.get("family_name");
    String givenName = (String) payload.get("given_name");

    // Use or store profile information
    // ...

  } else {
    System.out.println("Invalid ID token.");
  }

O método GoogleIdTokenVerifier.verify() verifica a assinatura JWT, a declaração aud, a declaração iss e a declaração exp.

Se você precisar validar que o token de ID representa uma conta de organização do Google Workspace ou do Cloud, verifique a declaração hd verificando o nome de domínio retornado pelo método Payload.getHostedDomain().

Como chamar o endpoint tokeninfo

Uma maneira fácil de validar uma assinatura de token de ID para depuração é usar o endpoint tokeninfo. Chamar esse endpoint envolve uma outra solicitação de rede que faz a maior parte da validação enquanto você testa a validação adequada e a extração de payload no seu próprio código. Ele não é adequado para uso em código de produção, porque as solicitações podem ser limitadas ou sujeitas a erros intermitentes.

Para validar um token de ID usando o endpoint tokeninfo, faça uma solicitação HTTPS POST ou GET para o endpoint e transmita seu token de ID no parâmetro id_token. Por exemplo, para validar o token "XYZ123", faça a seguinte solicitação GET:

https://oauth2.googleapis.com/tokeninfo?id_token=XYZ123

Se o token estiver assinado corretamente e as declarações iss e exp tiverem os valores esperados, você receberá uma resposta HTTP 200, em que o corpo contém as declarações de token de ID formatado em JSON. Veja um exemplo de resposta:

{
 // These six fields are included in all Google ID Tokens.
 "iss": "https://accounts.google.com",
 "sub": "110169484474386276334",
 "azp": "1008719970978-hb24n2dstb40o45d4feuo2ukqmcc6381.apps.googleusercontent.com",
 "aud": "1008719970978-hb24n2dstb40o45d4feuo2ukqmcc6381.apps.googleusercontent.com",
 "iat": "1433978353",
 "exp": "1433981953",

 // These seven fields are only included when the user has granted the "profile" and
 // "email" OAuth scopes to the application.
 "email": "testuser@gmail.com",
 "email_verified": "true",
 "name" : "Test User",
 "picture": "https://lh4.googleusercontent.com/-kYgzyAWpZzJ/ABCDEFGHI/AAAJKLMNOP/tIXL9Ir44LE/s99-c/photo.jpg",
 "given_name": "Test",
 "family_name": "User",
 "locale": "en"
}

Aviso:depois de receber essas declarações, você ainda precisa verificar se a declaração aud contém um dos IDs do cliente do seu app. Em caso afirmativo, o token é válido e destinado ao cliente, e você pode recuperar e usar com segurança o ID do Google exclusivo do usuário da declaração sub.

Se você precisar confirmar que o token de ID representa uma conta do Google Workspace, verifique a declaração hd, que indica o domínio hospedado do usuário. Precisa ser usado para restringir o acesso a um recurso apenas a membros de determinados domínios. A ausência dessa declaração indica que a conta não pertence a um domínio hospedado do Google Workspace.