Autentica con Google en Android

Puedes permitir que tus usuarios se autentiquen con Firebase mediante sus Cuentas de Google.

Antes de comenzar

Si aún no lo has hecho, agrega Firebase al proyecto de Android.

En el archivo Gradle (generalmente <project>/<app-module>/build.gradle) del módulo (nivel de app), agrega la dependencia de la biblioteca de Android para Firebase Authentication. Te recomendamos usar la BoM de Firebase para Android a fin de controlar las versiones de las bibliotecas.

Además, como parte de la configuración de Firebase Authentication, debes agregar el SDK de Servicios de Google Play a la app.

Kotlin+KTX

dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:32.0.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-ktx'

    // Also add the dependency for the Google Play services library and specify its version
    implementation 'com.google.android.gms:play-services-auth:20.5.0'
}

Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

(Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM

Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

Ten en cuenta que, si usas múltiples bibliotecas de Firebase en tu app, es muy recomendable que utilices la BoM para administrar las versiones de las bibliotecas para garantizar que todas las versiones sean compatibles.

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-ktx:22.0.0'

    // Also add the dependency for the Google Play services library and specify its version
    implementation 'com.google.android.gms:play-services-auth:20.5.0'
}

Java

dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:32.0.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:20.5.0'
}

Si usas la BoM de Firebase para Android, tu app siempre utilizará versiones compatibles de las bibliotecas de Firebase para Android.

(Alternativa) Agrega dependencias de la biblioteca de Firebase sin usar la BoM

Si eliges no usar la BoM de Firebase, debes especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

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:22.0.0'

    // Also add the dependency for the Google Play services library and specify its version
    implementation 'com.google.android.gms:play-services-auth:20.5.0'
}

Si aún no especificas la huella digital SHA de tu app, hazlo desde la página de configuración de Firebase console. Consulta Autenticación de tu cliente para obtener detalles sobre cómo obtener la huella digital SHA de tu app.
Habilita Google como método de acceso en Firebase console:
1. En Firebase console, abre la sección Auth.
2. En la pestaña Sign in method, habilita el método de acceso con Google y haz clic en Guardar.
Cuando se te solicite en la consola, descarga el archivo de configuración de Firebase actualizado (google-services.json), que ahora contiene la información del cliente de OAuth necesaria para el acceso con Google.
Mueve este archivo de configuración actualizado a tu proyecto de Android Studio. Para ello, reemplaza el archivo de configuración correspondiente (consulta Agrega Firebase a tu proyecto de Android).

Autentica con Firebase

Para integrar el acceso con One Tap de Google a tu app, sigue los pasos que se indican en la página Iniciar sesión a los usuarios con sus credenciales guardadas. Cuando configures el objeto BeginSignInRequest, llama a setGoogleIdTokenRequestOptions:

Kotlin+KTX

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

Debes pasar tu ID de cliente de “servidor” al método setGoogleIdTokenRequestOptions. Para encontrar el ID de cliente de OAuth 2.0, haz lo siguiente:

Abre la página Credenciales en la consola de GCP.
El ID de cliente de tipo aplicación web es el ID de cliente de OAuth 2.0 de tu servidor de backend.

Después de integrar el Acceso con Google, tu actividad de acceso tendrá un código similar al siguiente:

Kotlin+KTX

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;
      }
  }
}

En el método onCreate de tu actividad de acceso, obtén la instancia compartida del objeto FirebaseAuth:

Kotlin+KTX

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

Java

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

Cuando inicialices tu actividad, verifica que el usuario haya accedido:

Kotlin+KTX

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

En tu controlador onActivityResult() (consulta el paso 1), obtén el token de ID de Google del usuario, intercámbialo por una credencial de Firebase y úsala para autenticar con Firebase:

Kotlin+KTX

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

Si la llamada a signInWithCredential funciona correctamente, puedes usar el método getCurrentUser para obtener los datos de la cuenta del usuario.

Próximos pasos

Cuando un usuario accede por primera vez, se crea una cuenta de usuario nueva y se la vincula con las credenciales (el nombre de usuario y la contraseña, el número de teléfono o la información del proveedor de autenticación) que el usuario utilizó para acceder. Esta cuenta nueva se almacena como parte de tu proyecto de Firebase y se puede usar para identificar a un usuario en todas las apps del proyecto, sin importar cómo acceda.

En tus apps, puedes obtener la información básica del perfil del usuario a partir del objeto FirebaseUser. Consulta Administra usuarios.
En tus reglas de seguridad de Firebase Realtime Database y Cloud Storage, puedes obtener el ID del usuario único que accedió a partir de la variable auth y usarlo para controlar a qué datos podrá acceder.

Para permitir que los usuarios accedan a la app con varios proveedores de autenticación, puedes vincular las credenciales de estos proveedores con una cuenta de usuario existente.

Para salir de la sesión de un usuario, llama a signOut de la siguiente manera:

Kotlin+KTX

Firebase.auth.signOut()MainActivity.kt

Java

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