Login de conta vinculada para Android

O login com a conta vinculada ativa o Login com um toque do 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, que podem fazer login com um clique, sem precisar 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 com a 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á tiver o recurso de um toque ativado.

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

Como funciona

  1. Você ativa a exibição de contas vinculadas durante o fluxo de login com um toque.
  2. Se o usuário estiver conectado no Google e tiver vinculado a Conta do Google dele com a conta no seu serviço, um token de ID será retornado para a conta vinculada.
  3. O usuário recebe uma solicitação de login com um toque com a opção de fazer login no seu serviço com a conta vinculada.
  4. Se o usuário optar por continuar com a conta vinculada, o token de ID do usuário será retornado ao app. Compare esse token com o que foi enviado ao servidor na etapa 2 para identificar o usuário conectado.

Configurar

Configurar seu ambiente de desenvolvimento

Instale os serviços mais recentes do Google Play no host de desenvolvimento:

  1. Abra o Android SDK Manager.
  1. Em SDK Tools, encontre 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 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.3.0'
    }
    

Modificar o app Android para oferecer suporte ao login com a 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 de fazer o login do usuário.

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

  1. 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")
        }
    });
    
  2. 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()
    
  3. 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

Usar uma biblioteca de cliente da API do Google

Usar a biblioteca de cliente de API Java do Google é 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 do 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().