Autenticación con Firebase - Primera Parte: correo, Google y Facebook

Toda la información oficial de Firebase la pueden encontrar aquí.

El código completo para este Post lo pueden encontrar en Github

Este Post crea una actividad independiente para cada tipo de autenticación. El código de esa aplicación lo pueden encontrar en la rama master del repositorio en Github.

También podrán encontrar una app que utiliza todos los tipos de autenticación en una misma actividad. Este código lo pueden encontrar en la rama app_completa.

Pueden encontrar la segunda parte de este Post aquí. En la segunda parte encontrarán cómo iniciar sesión con Twitter y con usuarios anónimos.

Introducción

Firebase nos proporciona las herramientas necesarias para autenticar a nuestros usuarios. Ofrece soluciones para autenticar utilizando correo electrónico y contraseña, Google, Facebook, Twitter, Github, tu sistema personalizado de autenticación y además permite autenticar usuarios de manera anónima.

En este Post, el cual será la primera parte para utilizar autenticación con Firebase, veremos cómo implementar la creación de cuentas con correo y contraseña, iniciar sesión con correo y contraseña, con cuentas de Google y de Facebook.

Vamos a tomar el código como lo dejamos en el post anterior.

Para agregar autenticación a tu app, debemos de agregar esta dependencia al archivo build.gradle.

compile 'com.google.firebase:firebase-auth:9.8.0'

Crear cuenta con correo electrónico y contraseña

Todo el código para crear una cuenta con correo y contraseña lo pueden encontrar en la clase CrearCuentaActivity.java. Recuerden que necesitan agregar su archivo de google-services.json al proyecto, en la carpeta app, para que funcione la aplicación.

Firebase nos proporciona dos objetos que son los que nos permiten crear cuentas e iniciar sesión. Si bien iniciar sesión con cada proveedor (Google, Facebook) tiene sus detalles, en general estos dos objetos son los que necesitamos utilizar.

• FirebaseAuth
• FirebaseAuth.AuthStateListener

Necesitamos obtener la instancia de FirebaseAuth y crear el listener que escuchará los cambios de estado en la cuenta.

private void inicializarAutenticacion() {

    autenticacionFirebase = FirebaseAuth.getInstance();

    listenerAutenticacion = new FirebaseAuth.AuthStateListener() {
        @Override
        public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {

            FirebaseUser usuario = firebaseAuth.getCurrentUser();

            if (usuario != null) {
                // El usuario ha iniciado sesión
            } else {
                // El usuario no ha iniciado sesion aun
            }
        }
    };
}

El método de onAuthStateChanged() se manda llamar cuando hay un cambio en el estado de la sesión; por ejemplo cuando el usuario inició o cerró sesión. También cuando se termina de inicializar Firebase, por lo que al entrar a la actividad se ejecutará este método también. En este método podemos utilizar el objeto FirebaseAuth para obtener el FirebaseUser. Si obtenemos un valor de usuario, significa que ha iniciado sesión. Esta inicialización se debe de realizar en el onCreate().

Una vez creado el listener, necesitamos agregarlo a nuestro objeto FirebaseAuth. Esto se lleva a cabo en el onStart() de nuestra actividad. Así mismo, se debe de quitar el listener del objeto FirebaseAuth en el onStop().

@Override
public void onStart() {
    super.onStart();
    autenticacionFirebase.addAuthStateListener(listenerAutenticacion);
}

@Override
public void onStop() {
    super.onStop();
    if (listenerAutenticacion != null) {
        autenticacionFirebase.removeAuthStateListener(listenerAutenticacion);
    }
}

Por último, vamos a añadir las instrucciones para crear la cuenta. En nuestro proyecto hay un botón al cual se le asigna un onClickListener() que manda llamar el método crearCuenta(String email, String password). En este método, lo que tenemos que hacer es llamar el método createUserWithEmailAndPassword() del objeto autenticaciónFirebase. De igual manera se le agrega un listener, addOnCompleteListener() el cual se llamará cuando se termine de crear el usuario y nos indicará si hubo algún error o si la operación fue exitosa.

private void crearCuenta(String email, String password) {

    autenticacionFirebase.createUserWithEmailAndPassword(email, password)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {

                    if (!task.isSuccessful()) {
                        // Hubo algún error.
                    } else {
                        // La operación de creación de cuenta fue exitosa.
                    }
                }
            });
}

El código de ejemplo también les proporciona el layout con los campos de texto para correo y contraseña, un círculo para mostrar el progreso mientras se hace la creación de cuenta, así como una validación simple del correo y la contraseña. De igual manera, hay código para mostrar correos electrónicos que se encuentren asociados al teléfono. Cabe destacar que Firebase permite contraseñas de al menos seis caracteres, si no, regresa un error.

Activación en la Consola

Para que nuestro código funcione, necesitamos ir a la consola de Firebase. Una vez ahí, en el menú del lado izquierdo hay que seleccionar la opción de Autenticación. Esta pantalla nos presenta tres pestañas. Necesitamos abrir la pestaña Método de Inicio de Sesión, que se muestra en la siguiente imagen.

Una vez en esta pantalla, daremos clic en la opción de Correo electrónico/contraseña. Se abrirá un diálogo donde podemos activar esta opción y guardar los cambios.

Ahora podemos iniciar nuestra app y crear una cuenta con correo electrónico y contraseña.

Podemos ver que creamos la cuenta y además iniciamos sesión. Ahora tenemos acceso al objeto FirebaseUser. Pueden revisar el método asignarUsuario(FirebaseUser usuarioFirebase).

Inicio de Sesión con Correo Electrónico y Contraseña

El código para iniciar sesión con correo electrónico y contraseña lo pueden encontrar en IniciarSesionCorreoContraseñaActivity.java.

Para iniciar sesión, se deben de seguir pasos muy similares al punto anterior, cuando creamos la cuenta. Primero se debe de inicializar el listener FirebaseAuth.AuthStateListener y posteriormente se debe de agregar el listener al objeto FirebaseAuth en el onStart() y quitarlo en el onStop().

private void inicializarAutenticacion() {

    autenticacionFirebase = FirebaseAuth.getInstance();

    listenerAutenticacion = new FirebaseAuth.AuthStateListener() {
        @Override
        public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
            FirebaseUser usuario = firebaseAuth.getCurrentUser();

            if (usuario != null) {
                // El usuario ya inició sesión.
            } else {
                // El usuario no ha iniciado sesión aún.
            }
        }
    };
}

@Override
public void onStart() {
    super.onStart();
    autenticacionFirebase.addAuthStateListener(listenerAutenticacion);
}

@Override
public void onStop() {
    super.onStop();
    if (listenerAutenticacion != null) {
        autenticacionFirebase.removeAuthStateListener(listenerAutenticacion);
    }
}

Por último se debe de llamar el método signInWithEmailAndPassword() del objeto FirebaseAuth para inciar sesión. Se le agrega un listener con addOnCompleteListener() para escuchar los cambios y ver si se pudo iniciar sesión o no. De igual manera, al terminar la operación de iniciar sesión, se ejecutará el método onAuthStateChanged() del listener FirebaseAuth.AuthStateListener en donde podremos obtener el usuario.

private void iniciarSesion(String email, String password) {

    autenticacionFirebase.signInWithEmailAndPassword(email, password)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    mostrarProgreso(false);

                    if (!task.isSuccessful()) {
                        // Hubo algún error
                    } else {
                        // Se inició sesión. Se llamará el listener.
                    }
                }
            });
}

Se incluye además de esto, el mismo código que en la clase CrearCuentaActivity.java., para validar los datos, mostrar el círculo de progreso, mostrar las cuentas asociadas al teléfono.

Podemos iniciar sesión con la cuenta de correo que utilizamos anteriormente.

Una vez iniciada la sesión podemos tener acceso al FirebaseUser. Pueden ver como en el método asignarUsuario(FirebaseUser usuarioFirebase) obtenemos el correo del usuario utilizado para iniciar sesión.

Cerrar Sesión

Para cerrar sesión, se tiene que llamar el método signOut() del objeto FirebaseAuth. Pueden revisar el método cerrarSesion().

autenticacionFirebase.signOut();

Inicio de sesión con Google

Utilizar Google Sign-in para iniciar sesión involucra algunos pasos más. Para empezar, hay que activar el inicio de sesión con Google en la consola de Firebase.

Activar Inicio de Sesión con Google en la Consola

En el menú de la izquierda hay que ir a Autenticación y seleccionar la pestaña de Métodos de Inicio de Sesión. Una vez ahí, seleccionamos la opción de Google para habilitarla. Se muestra una advertencia de necesitar la huella digital SHA1 para poder hacer esto. Esto lo hicimos en el post anterior por lo que no debe de haber problema.

Antes de guardar los cambios, necesitamos obtener un valor ID de cliente web que se encuentra en esta pantalla. Debemos expandir la opción de Configuración del SDK web (opcional). Ahí encontraremos el ID de cliente web. Copien y guarden este valor que lo necesitaremos más adelante. Después de guardar este valor podemos guardar los cambios.

Dependencias

Hay que agregar la dependencia de google-play-services-auth en nuestro archivo build.gradle.

compile 'com.google.android.gms:play-services-auth:9.8.0'

En esta dependencia viven los objetos de Google Sign In que utilizaremos más adelante.

Layout

Lo primero que necesitamos hacer, es crear nuestro layout. En él, vamos a agregar un botón SignInButton. En nuestro ejemplo, el layout que utilizamos es activity_iniciar_sesion_google.xml

<com.google.android.gms.common.SignInButton
    android:id="@+id/boton_sesion_google"
    android:layout_width="match_parent"
    android:layout_height="wrap_content" />

Inicializar Firebase

El código para iniciar sesión con Google lo pueden encontrar en IniciarSesionGoogleActivity.java.

Al igual que en las secciones anteriores, debemos inicializar el objeto FirebaseAuth y el FirebaseAuth.AuthStateListener. También hay que agregar el listener al objeto FirebaseAuth en el onStart() y quitarlo en el onStop().

private void inicializarAutenticacion() {

    autenticacionFirebase = FirebaseAuth.getInstance();

    listenerAutenticacion = new FirebaseAuth.AuthStateListener() {
        @Override
        public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
            FirebaseUser usuario = firebaseAuth.getCurrentUser();
            if (usuario != null) {
                // Usuario ha iniciado sesión.
            } else {
                // Usuario no ha iniciado sesión aún.
            }
        }
    };
}

@Override
public void onStart() {
    super.onStart();
    autenticacionFirebase.addAuthStateListener(listenerAutenticacion);
}

@Override
public void onStop() {
    super.onStop();
    if (listenerAutenticacion != null) {
        autenticacionFirebase.removeAuthStateListener(listenerAutenticacion);
    }
}

Inicializar Google Sign-in

Debemos de inicializar también los objetos de Google que utilizaremos. Necesitamos dos objetos:

• GoogleSignInOptions
• GoogleApiClient

GoogleSignInOptions nos permite configurar la manera con que iniciaremos sesión. Por ahora utilizaremos las opciones por default de inicio de sesión (DEFAULT_SIGN_IN). También nos permite agregar opciones que pediremos al usuario, en este caso pediremos acceso a su cuenta de correo electrónico. De igual manera, el ID de cliente web que guardamos al inicio de esta sección, lo debemos proporcionar. Reemplazen este código getString(R.string.default_web_client_id) con el valor del ID de cliente web suyo.

GoogleSignInOptions opcionesInicioSesionGoogle = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
        .requestIdToken(getString(R.string.default_web_client_id))
        .requestEmail()
        .build();

GoogleApiClient nos permite iniciar la actividad para iniciar sesión con Google. A este objeto le indicamos que utilizaremos la API de Google Sign In, además de agregarle los listeners necesarios y el objeto GoogleSignInOptions configurado previamente.

clienteApiGoogle = new GoogleApiClient.Builder(this)
        .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */)
        .addApi(Auth.GOOGLE_SIGN_IN_API, opcionesInicioSesionGoogle)
        .build();

Iniciar Flujo de Inicio de Sesión con Google

Para iniciar el flujo de inicio de sesión con Google, necesitamos agregarle un onClickListener a nuestro botón SignInButton.

botonIniciarSesion = (SignInButton) findViewById(R.id.boton_sesion_google);
botonIniciarSesion.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        iniciarSesionConGoogle();
    }
});

Al hacer clic en el botón, necesitamos lanzar un Intent el cual se crea utilizando el objeto GoogleApiClient que acabamos de configurar.

Intent intent = Auth.GoogleSignInApi.getSignInIntent(clienteApiGoogle);

Iniciaremos una actividad por resultado, pasando el intent y un código de solicitud (en nuestro caso es CS_INICIAR_SESION = 9001).

startActivityForResult(intent, CS_INICIAR_SESION);

Lo que hace el startActivityForResult() es iniciar la actividad de inicio de sesión de Google y regresar un resultado a nuestra actividad. Este resultado lo tenemos que obtener en el método onActivityResult().

Primero debemos de comprobar que el codigo de solicitud recibido sea el mismo que el que enviamos. Posteriormente, en el Intent datos que recibimos viene la información de la cuenta seleccionada del usuario. Debemos de obtener un GoogleSignInResult utilizando este Intent. Podemos utilizarlo también para ver si el inicio de sesión fue exitoso. Si fue exitoso, de este objeto podemos obtener la cuenta del usuario, con el objeto GoogleSignInAccount. Por último, utilizando este objeto, debemos de iniciar sesión en Firebase.

@Override
public void onActivityResult(int codigoSolicitud, int codigoResultado, Intent datos) {
    super.onActivityResult(codigoSolicitud, codigoResultado, datos);

    if (codigoSolicitud == CS_INICIAR_SESION) {

        GoogleSignInResult resultado = Auth.GoogleSignInApi.getSignInResultFromIntent(datos);
        if (resultado.isSuccess()) {
            GoogleSignInAccount cuenta = resultado.getSignInAccount();
            inicioSesionFirebaseConCuentaGoogle(cuenta);
        } else {
            // Hubo un error
        }
    }
}

Iniciando sesión en Firebase con una cuenta Google

Utilizando un Id Token que tiene nuestro objeto GoogleSignInAccount obtenido previamente, necesitamos obtener una credencial de tipo AuthCredential. Esta credencial se obtiene utilizando el objeto de Firebase GoogleAuthProvider. Esta credencial se utilizará para iniciar sesión.

Por último, llamareoms el método signInWithCredential() de nuestro objeto FirebaseAuth, pasándole la credencial obtenida. De igual manera se le agrega un OnCompleteListener, con el cual podemos ver si hubo un error al iniciar sesión con Firebase. Cuando se termine de ejecutar este método, se manda llamar el método onAuthStateChanged() de nuestro FirebaseAuth.AuthStateListener, con el cual podemos obtener la información del usuario.

private void inicioSesionFirebaseConCuentaGoogle(GoogleSignInAccount cuentaGoogle) {

    AuthCredential credencial = GoogleAuthProvider.getCredential(cuentaGoogle.getIdToken(), null);
    autenticacionFirebase.signInWithCredential(credencial)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {

                    if (!task.isSuccessful()) {
                        // Hubo un error
                    }
                }
            });
}

Al terminar de agregar este código, podremos ser capaces de iniciar sesión con Google Sign-In. IMPORTANTE: recuerden agregar su ID al objeto GoogleSignInOptions y de activar la opción de iniciar sesión con Google Sign-In en la consola.

Al iniciar el flujo de inicio de sesión, se nos presenta un diálogo para elegir una cuenta:

La primera vez que inicies sesión con Google, tendrás que dar permiso a la app para utilizar tu información.

Al concluir este proceso, hemos iniciado sesión con Google.

Inicio de Sesión con Facebook

Ahora aprenderemos como utilizar Facebook para iniciar sesión con Firebase.

Creando tu App en Facebook

Lo primero que tenemos que hacer es crear nuestra aplicación en Facebook. Hay que entrar a la página de Facebook Developers. En esta página podrán ver todas las aplicaciones que tengan actualmente así como agregar nuevas apps.

Para agregar una nueva aplicación, hay que dar clic en el botón Agregar una nueva app.

Nos pedirán algunos datos de nuestra aplicación: nombre de la app y algún correo electrónico para contacto, así como la categoría a la que pertenece nuestra app. Al llenar estos campos, dar clic en el botón para crear el ID de tu app.

Una vez creada nuestra app, entramos a la consola donde la podemos administrar. Necesitamos obtener un par de valores de nuestra app de Facebook. Para esto, hay que ir a Configuración -> Básica. Ahí podemos ver el Identificador de la aplicación y podemos mostrar la Clave secreta de la aplicación. Necesitamos guardar estos dos valores para utilizarlos en Firebase posteriormente.

Ahora debemos agregar una plataforma, que en nuestro caso será Android. Esto lo pueden hacer en la parte inferior de la misma pantalla, en Configuración -> Básica.

Una vez agregada la plataforma Android, nos piden algunos datos. Debemos agregar el paquete de nuestra app y el nombre de la clase que hará el inicio de sesión con Facebook.

De igual manera nos piden los hashes de clave de nuestra app.

Obteniendo los Hashes de clave

Para obtener los Hashes de clave de nuestra app necesitamos utilizar OpenSSL. En Windows pueden descargar OpenSSL aquí. Hay que extraer su contenido y después debemos de crear una carpeta en C:/, en mi caso cree una carpeta llamada c:/openssl, en donde debemos de pegar todo el contenido del archivo que extrajimos previamente.

Necesitamos saber la ubicación de nuestro archivo keystore (esto aplica tanto para su keystore de desarrollo como para el de producción, en caso de que lo tengan.). La ubicación para el keystore de desarrollo en Windows es %USERPROFILE%.android\debug.keystore

Debemos ir a la ubicación del programa keytool.exe la cual es c:/Program Files/Java/jdk1.8.0_92/bin

Una vez ahí, ejecutaremos la siguiente instrucción

keytool -exportcert -alias androiddebugkey -keystore  %USERPROFILE%\.android\debug.keystore | "C:\openssl\bin\openssl" sha1 -binary |"C:\openssl\bin\openssl" base64

Les pedirá el password de su keystore el cual es “android” si utilizan el de desarrollo. Con esto obtendrán el hash y lo deberán de ingresar en la consola de Facebook.

Habilitar Inicio de Sesión con Facebook en Firebase

Es momento de regresar a la consola de Firebase. En el menú de la izquierda hay que ir a Autenticación, y seleccionar la pestaña de Método de Inicio de Sesión. Hay que habilitar la opción de Facebook. Esto nos abrirá un diálogo en donde tenemos que ingresar nuestra ID de aplicación y la Clave secreta que obtuvimos en la consola de Facebook.

En la parte inferior de este diálogo hay una URL de la forma my-app-12345.firebaseapp.com/__/auth/handler. Esta URL hay que copiarla y agregarla en la consola de Facebook.

Una vez en la consola de Facebook hay que ir en el menú de la izquierda a Inicio de Sesión con Facebook. Hay un campo llamado URI de redireccionamiento de OAuth válidos. En este campo hay que pegar la URL que obtuvimos en Firebase.

Agregar el SDK de Facebook

Después de terminar con la configuración de nuestra app en Facebook y en Firebase, llegó el momento de agregar el SDK de Facebook a nuestra app. Para empezar, en el build.gradle del proyecto, agregar en repositories mavenCentral(). Esto nos permitirá descargar la dependencia de Facebook.

repositories {
    jcenter()
    mavenCentral()
}

Ahora debemos de agregar la dependencia en el build.gradle de la app:

compile 'com.facebook.android:facebook-android-sdk:4.17.0'

Facebook necesita saber el ID de nuestra aplicación que obtuvimos previamente en la consola de Facebook. Debemos agregar un atributo metadata en el manifest de nuestra app. Debe tener como nombre com.facebook.sdk.ApplicationId y como valor un string con el *ID de nuestra aplicación.

<meta-data android:name="com.facebook.sdk.ApplicationId" android:value="@string/facebook_app_id"/>

Con esto, estamos listos para agregar el código para iniciar sesión. Necesitamos agregar el botón de inicio de sesión de Facebook. En nuestro layout, activity_iniciar_sesion_facebook.xml, vamos a agregar este botón.

<com.facebook.login.widget.LoginButton
    android:id="@+id/login_button"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center_horizontal"
    android:layout_marginTop="30dp"
    android:layout_marginBottom="30dp" />

El código para iniciar sesión con Facebook lo pueden encontrar en IniciarSesionFacebookActivity.java

En la actividad debemos de inicializar el SDK de Facebook ANTES de llamar el setContentView() con nuestro layout.

FacebookSdk.sdkInitialize(getApplicationContext());

También debemos de crear un CallbackManager que es el objeto de Facebook que maneja las llamadas desde la actividad o fragment.

manejadorDeLlamadas = CallbackManager.Factory.create();

Facebook requiere que le agreguemos al LoginButton los permisos que necesitamos pedirle al usuario. Firebase nos pide que al menos pidamos los permisos de email y public_profile. Igualmente se deben de registrar una llamada de regreso (callback) para manejar los cambios de sesión de Facebook. Este callback nos permitirá manejar los casos en que el inicio de sesión sea exitoso, cuando el usuario cancele el inicio de sesión o cuando se presente algún error al iniciar sesión. Cuando iniciemos con éxito la sesión con Facebook, debemos iniciar sesión con Firebase, utilizando el accessToken que nos provee Facebook mediante el LoginResult:

FacebookSdk.sdkInitialize(getApplicationContext());
setContentView(R.layout.activity_iniciar_sesion_facebook);

manejadorDeLlamadas = CallbackManager.Factory.create();

LoginButton botonLogin = (LoginButton) findViewById(R.id.boton_login_facebook);
botonLogin.setReadPermissions("email", "public_profile");
botonLogin.registerCallback(manejadorDeLlamadas, new FacebookCallback<LoginResult>() {
    @Override
    public void onSuccess(LoginResult loginResult) {
        iniciarSesionFirebaseConFacebook(loginResult.getAccessToken());
    }

    @Override
    public void onCancel() {
        Toast.makeText(IniciarSesionFacebookActivity.this, "Usuario canceló inicio de sesión con Facebook.", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onError(FacebookException error) {
        Toast.makeText(IniciarSesionFacebookActivity.this, "Hubo un error al iniciar sesión con Facebook.", Toast.LENGTH_SHORT).show();
    }
});

Para terminar con el código de Facebook para iniciar sesión, se debe de agregar el método onActivityResult() donde se llame al método onActivityResult() del manejador de llamadas de Facebook:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    manejadorDeLlamadas.onActivityResult(requestCode, resultCode, data);
}

Inicializando Firebase

Este paso es idéntico a lo realizado previamente para iniciar sesión con Google y con correo electrónico. Hay que obtener la instancia de FirebaseAuth, crear el listener y agregar y quitar el listener en el onStart() y en el onStop(). Recuerden que el método onAuthStateChanged() del FirebaseAuth.AuthStateListener es el que se manda llamar cuando se detecta algún cambio de sesión con Firebase:

private void inicializarAutenticacion() {
    autenticacionFirebase = FirebaseAuth.getInstance();

    listenerAutenticacion = new FirebaseAuth.AuthStateListener() {
        @Override
        public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
            FirebaseUser usuario = firebaseAuth.getCurrentUser();
            if (usuario != null) {

            } else {

            }
        }
    };
}

@Override
public void onStart() {
    super.onStart();
    autenticacionFirebase.addAuthStateListener(listenerAutenticacion);
}

@Override
public void onStop() {
    super.onStop();
    if (listenerAutenticacion != null) {
        autenticacionFirebase.removeAuthStateListener(listenerAutenticacion);
    }
}

Por último, necesitamos iniciar sesión con Firebase utilizando el AccessToken que obtuvimos de Facebook. Se crea una credencial con el token de acceso y se manda llamar el método signInWithCredential() del objeto FirebaseAuth utilizando la credencial creada.

private void iniciarSesionFirebaseConFacebook(AccessToken tokenDeAcceso) {
    AuthCredential credencial = FacebookAuthProvider.getCredential(tokenDeAcceso.getToken());
    autenticacionFirebase.signInWithCredential(credencial)
            .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {

                    if (!task.isSuccessful()) {
                        // Hubo un error al iniciar sesión con Firebase
                    }
                }
            });
}

Después de este paso, podemos hacer login con nuestra cuenta de Facebook.

La primera vez, nos indicará los permisos que va a utilizar la app.

Al aceptar los permisos y continuar, logramos iniciar sesión.

Cerrar sesión con Facebook y Firebase

Facebook nos proporciona el botón de Logout o Cerrar Sesión. También nos proporciona un objeto AccessTokenTracker el cual tiene un listener con el método onCurrentAccessTokenChanged() el cual se manda llamar cada vez que el token de Facebook cambia, lo cual ocurre al iniciar o cerrar sesión. Cuando se cierra sesión en Facebook, este valor viene nulo y podemos cerrar sesión también con Firebase.

AccessTokenTracker accessTokenTracker = new AccessTokenTracker() {
    @Override
    protected void onCurrentAccessTokenChanged(
            AccessToken oldAccessToken,
            AccessToken currentAccessToken) {

        if (currentAccessToken == null){
            cerrarSesionFirebase();
        }
    }
};

Conclusión

En esta primera parte, aprendimos cómo utilizar Firebase para iniciar sesión utilizando correo y contraseña, una cuenta de Google y una cuenta de Facebook. Como pudimos ver, el código de Firebase para los tres escenarios es prácticamente el mismo: obtener la instancia de FirebaseAuth, crear un listener de tipo FirebaseAuth.AuthStateListener, agregar y quitar el listener en el onStart() y onStop().

Para iniciar sesión con cualquiera de los tres proveedores, el objeto FirebaseAuth nos proporcina los métodos necesarios.

• createUserWithEmailAndPassword(): para crear una cuenta con correo y contraseña.
• signInWithEmailAndPassword(): para iniciar sesión con correo y contraseña.
• signInWithCredential(): para iniciar sesión con Google o Facebook.

También Firebase nos provee dos Providers, para crear una credencial y poder iniciar sesión:

• GoogleAuthProvider.getCredential(): para crear la credencial utilizando el TokenId obtenido de iniciar sesión con Google.
• FacebookAuthProvider.getCredential(): para crear la credencial utilizando el AccessToken obtenido al iniciar sesión con Facebook.

Antes de poder iniciar sesión con Firebase, es necesario configurar los objetos de Google, al utilizar Google para iniciar sesión, así como crear y configurar tu app en Facebook y configurar el SDK en tu código, al utilizar Facebook para iniciar sesión, como se mostró en este post.

En la segunda parte de autenticación con Firebase, aprenderemos a iniciar sesión con Twitter y Github, así como tener usuarios anónimos y la manera en que podemos combinar varios proveedores para iniciar sesión con una misma cuenta.