Autenticar com o Google no Android

Você pode permitir a autenticação de usuários no Firebase com Contas do Google.

Antes de começar

1. Adicione o Firebase ao projeto para Android, caso ainda não tenha feito isso.

2. No arquivo Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle), adicione a dependência da biblioteca do Firebase Authentication para Android. Recomendamos o uso do Firebase Android BoM para controlar o controle de versões da biblioteca.

   Além disso, como parte da configuração do Firebase Authentication, é necessário adicionar o SDK do Google Play Services ao seu app.

   dependencies {
       // Import the BoM for the Firebase platform
       implementation(platform("com.google.firebase:firebase-bom:33.7.0"))
   
       // Add the dependency for the Firebase Authentication library
       // When using the BoM, you don't specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-auth")
   
       // Also add the dependency for the Google Play services library and specify its version
       implementation("com.google.android.gms:play-services-auth:21.3.0")
   }

   Com a Firebase Android BoM, seu app sempre vai usar versões compatíveis das bibliotecas do Firebase para Android.

   (Alternativa) Adicionar dependências das bibliotecas do Firebase sem usar o BoM

   Se você preferir não usar o Firebase BoM, especifique cada versão das bibliotecas do Firebase na linha de dependência correspondente.

   Se você usa várias bibliotecas do Firebase no app, recomendamos utilizar o BoM para gerenciar as versões delas, porque isso ajuda a garantir a compatibilidade de todas as bibliotecas.

   dependencies {
       // Add the dependency for the Firebase Authentication library
       // When NOT using the BoM, you must specify versions in Firebase library dependencies
       implementation("com.google.firebase:firebase-auth:23.1.0")
   
       // Also add the dependency for the Google Play services library and specify its version
       implementation("com.google.android.gms:play-services-auth:21.3.0")
   }

   Está procurando um módulo de biblioteca específico do Kotlin? A partir de outubro de 2023 (Firebase BoM 32.5.0), os desenvolvedores Kotlin e Java poderão depender do módulo da biblioteca principal. Para mais detalhes, consulte Perguntas frequentes sobre essa iniciativa).

3. Caso você ainda não tenha especificado a impressão digital SHA do app, faça isso na página Configurações do console do Firebase. Consulte Como autenticar seu cliente para mais detalhes sobre como conseguir a impressão digital SHA.

4. Ative o Google como um método de login no Console do Firebase:
   1. No console do Firebase, abra a seção Auth.
   2. Na guia Método de login, ative o método de login do Google e clique em Salvar.

5. Quando aparecer a solicitação no console, faça o download do arquivo de configuração atualizado do Firebase (google-services.json), que agora contém as informações do cliente OAuth necessárias para o login do Google.

6. Mova esse arquivo de configuração atualizado para seu projeto do Android Studio substituindo o arquivo de configuração correspondente desatualizado. (Consulte Adicionar o Firebase ao projeto do Android).

Autenticar com o Firebase

1. Para integrar o login com um toque do Google no seu app, siga as etapas na página Fazer login de usuários com as credenciais salvas. Quando você configurar o objeto BeginSignInRequest, chame setGoogleIdTokenRequestOptions:

   Kotlin

   signInRequest = BeginSignInRequest.builder()
               .setGoogleIdTokenRequestOptions(
                   BeginSignInRequest.GoogleIdTokenRequestOptions.builder()
                       .setSupported(true)
                       // Your server's client ID, not your Android client ID.
                       .setServerClientId(getString(R.string.your_web_client_id))
                       // Only show accounts previously used to sign in.
                       .setFilterByAuthorizedAccounts(true)
                       .build())
               .build()

   Java

   signInRequest = BeginSignInRequest.builder()
       .setGoogleIdTokenRequestOptions(GoogleIdTokenRequestOptions.builder()
               .setSupported(true)
               // Your server's client ID, not your Android client ID.
               .setServerClientId(getString(R.string.default_web_client_id))
               // Only show accounts previously used to sign in.
               .setFilterByAuthorizedAccounts(true)
               .build())
       .build();
       

   É necessário transmitir o ID do cliente "servidor" para o método setGoogleIdTokenRequestOptions. Para encontrar o ID do cliente OAuth 2.0:
   1. Abra a página Credenciais no Console do Google Cloud:
   2. O ID do cliente de tipo Aplicativo da Web é seu ID do cliente OAuth 2.0 do servidor de back-end.
   Depois de integrar o Login do Google, sua atividade de login terá um código semelhante a:

   Kotlin

   class YourActivity : AppCompatActivity() {
   
       // ...
       private val REQ_ONE_TAP = 2  // Can be any integer unique to the Activity
       private var showOneTapUI = true
       // ...
   
       override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
           super.onActivityResult(requestCode, resultCode, data)
   
           when (requestCode) {
                REQ_ONE_TAP -> {
                   try {
                       val credential = oneTapClient.getSignInCredentialFromIntent(data)
                       val idToken = credential.googleIdToken
                       when {
                           idToken != null -> {
                               // Got an ID token from Google. Use it to authenticate
                               // with Firebase.
                               Log.d(TAG, "Got ID token.")
                           }
                           else -> {
                               // Shouldn't happen.
                               Log.d(TAG, "No ID token!")
                           }
                       }
                   } catch (e: ApiException) {
                       // ...
               }
           }
       }
       // ...
   }

   Java

   public class YourActivity extends AppCompatActivity {
   
     // ...
     private static final int REQ_ONE_TAP = 2;  // Can be any integer unique to the Activity.
     private boolean showOneTapUI = true;
     // ...
   
     @Override
     protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
         super.onActivityResult(requestCode, resultCode, data);
   
         switch (requestCode) {
             case REQ_ONE_TAP:
                 try {
                     SignInCredential credential = oneTapClient.getSignInCredentialFromIntent(data);
                     String idToken = credential.getGoogleIdToken();
                     if (idToken !=  null) {
                         // Got an ID token from Google. Use it to authenticate
                         // with Firebase.
                         Log.d(TAG, "Got ID token.");
                     }
                 } catch (ApiException e) {
                     // ...
                 }
                 break;
         }
     }
   }

2. No método onCreate da atividade de login, acesse a instância compartilhada do objeto FirebaseAuth:

   Kotlin

   private lateinit var auth: FirebaseAuth
   // ...
   // Initialize Firebase Auth
   auth = Firebase.auth
   GoogleSignInActivity.kt

   Java

   private FirebaseAuth mAuth;
   // ...
   // Initialize Firebase Auth
   mAuth = FirebaseAuth.getInstance();
   GoogleSignInActivity.java

3. Ao inicializar sua atividade, verifique se o usuário está conectado no momento:

   Kotlin

   override fun onStart() {
       super.onStart()
       // Check if user is signed in (non-null) and update UI accordingly.
       val currentUser = auth.currentUser
       updateUI(currentUser)
   }
   GoogleSignInActivity.kt

   Java

   @Override
   public void onStart() {
       super.onStart();
       // Check if user is signed in (non-null) and update UI accordingly.
       FirebaseUser currentUser = mAuth.getCurrentUser();
       updateUI(currentUser);
   }
   GoogleSignInActivity.java

4. No gerenciador onActivityResult() (consulte a etapa 1), receba o token de ID do Google do usuário, troque-o por uma credencial do Firebase e faça a autenticação:

   Kotlin

   val googleCredential = oneTapClient.getSignInCredentialFromIntent(data)
   val idToken = googleCredential.googleIdToken
   when {
       idToken != null -> {
           // Got an ID token from Google. Use it to authenticate
           // with Firebase.
           val firebaseCredential = GoogleAuthProvider.getCredential(idToken, null)
           auth.signInWithCredential(firebaseCredential)
                   .addOnCompleteListener(this) { task ->
                       if (task.isSuccessful) {
                           // Sign in success, update UI with the signed-in user's information
                           Log.d(TAG, "signInWithCredential:success")
                           val user = auth.currentUser
                           updateUI(user)
                       } else {
                           // If sign in fails, display a message to the user.
                           Log.w(TAG, "signInWithCredential:failure", task.exception)
                           updateUI(null)
                       }
                   }
       }
       else -> {
           // Shouldn't happen.
           Log.d(TAG, "No ID token!")
       }
   }

   Java

   SignInCredential googleCredential = oneTapClient.getSignInCredentialFromIntent(data);
   String idToken = googleCredential.getGoogleIdToken();
   if (idToken !=  null) {
       // Got an ID token from Google. Use it to authenticate
       // with Firebase.
       AuthCredential firebaseCredential = GoogleAuthProvider.getCredential(idToken, null);
       mAuth.signInWithCredential(firebaseCredential)
               .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                   @Override
                   public void onComplete(@NonNull Task<AuthResult> task) {
                       if (task.isSuccessful()) {
                           // Sign in success, update UI with the signed-in user's information
                           Log.d(TAG, "signInWithCredential:success");
                           FirebaseUser user = mAuth.getCurrentUser();
                           updateUI(user);
                       } else {
                           // If sign in fails, display a message to the user.
                           Log.w(TAG, "signInWithCredential:failure", task.getException());
                           updateUI(null);
                       }
                   }
               });
   }

   Se a chamada para signInWithCredential for concluída, será possível usar o método getCurrentUser para coletar os dados da conta do usuário.

Próximas etapas

Depois que um usuário faz login pela primeira vez, uma nova conta de usuário é criada e vinculada às credenciais, que podem ser o número do telefone, o nome de usuário e a senha ou as informações do provedor de autenticação. Essa nova conta é armazenada como parte do projeto do Firebase e pode ser usada para identificar um usuário em todos os apps do projeto, seja qual for o método de login utilizado.

• Você pode receber as informações básicas de perfil do usuário do objeto FirebaseUser nos seus aplicativos. Consulte Gerenciar usuários.

• Nas Regras de segurança Firebase Realtime Database e Cloud Storage, você pode acessar o ID exclusivo do usuário conectado pela variável auth e usar essas informações para controlar quais dados um usuário pode acessar.

Os usuários podem fazer login no app usando vários provedores de autenticação. Basta vincular as credenciais desses provedores a uma conta de usuário.

Para desconectar um usuário, chame signOut:

Kotlin

Firebase.auth.signOut()
MainActivity.kt

Java

FirebaseAuth.getInstance().signOut();
MainActivity.java