Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Vincula varios proveedores de autenticación con una cuenta mediante JavaScript

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. Los usuarios se pueden identificar con el mismo ID de usuario de Firebase, sin importar el proveedor de autenticación que hayan usado para acceder. Por ejemplo, un usuario que accedió con una contraseña puede vincular una Cuenta de Google y después usar cualquiera de los dos métodos para acceder. Por otra parte, un usuario anónimo puede vincular una cuenta de Facebook y luego acceder con Facebook para continuar usando la app.

Antes de comenzar

Agrega compatibilidad para dos o más proveedores de autenticación (posiblemente con la inclusión de la autenticación anónima) a tu app.

Para vincular credenciales de un proveedor de autenticación como Google o Facebook con una cuenta de usuario existente, haz lo siguiente:

  1. Permite que el usuario acceda mediante cualquier proveedor o método de autenticación.
  2. Obtén el objeto AuthProvider que corresponde al proveedor que deseas vincular con la cuenta del usuario. Ejemplos:

    Web v8

    var googleProvider = new firebase.auth.GoogleAuthProvider();
    var facebookProvider = new firebase.auth.FacebookAuthProvider();
    var twitterProvider = new firebase.auth.TwitterAuthProvider();
    var githubProvider = new firebase.auth.GithubAuthProvider();

    Web v9

    import { GoogleAuthProvider, FacebookAuthProvider, TwitterAuthProvider, GithubAuthProvider } from "firebase/auth";
    
    const googleProvider = new GoogleAuthProvider();
    const facebookProvider = new FacebookAuthProvider();
    const twitterProvider = new TwitterAuthProvider();
    const githubProvider = new GithubAuthProvider();
  3. Pídele al usuario que acceda con el proveedor que deseas vincular. Para pedir a tus usuarios que accedan, puedes mostrar una ventana emergente o redireccionarlos a la página de acceso del proveedor. En dispositivos móviles, se prefiere el método de redireccionamiento.
    • Para acceder con una ventana emergente, llama a linkWithPopup:

      Web v8

      auth.currentUser.linkWithPopup(provider).then((result) => {
        // Accounts successfully linked.
        var credential = result.credential;
        var user = result.user;
        // ...
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });

      Web v9

      import { getAuth, linkWithPopup, GoogleAuthProvider } from "firebase/auth";
      const provider = new GoogleAuthProvider();
      
      const auth = getAuth();
      linkWithPopup(auth.currentUser, provider).then((result) => {
        // Accounts successfully linked.
        const credential = GoogleAuthProvider.credentialFromResult(result);
        const user = result.user;
        // ...
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });
    • Para acceder mediante el redireccionamiento a la página de acceso del proveedor, llama a linkWithRedirect:

      Web v8

      auth.currentUser.linkWithRedirect(provider)
        .then(/* ... */)
        .catch(/* ... */);

      Web v9

      import { getAuth, linkWithRedirect, GoogleAuthProvider } from "firebase/auth";
      const provider = new GoogleAuthProvider();
      
      const auth = getAuth();
      linkWithRedirect(auth.currentUser, provider)
        .then(/* ... */)
        .catch(/* ... */);
      Después de que el usuario accede, se lo redirecciona de vuelta a tu página. Luego, para recuperar el resultado del acceso, puedes llamar a getRedirectResult cuando tu página cargue:

      Web v8

      auth.getRedirectResult().then((result) => {
        if (result.credential) {
          // Accounts successfully linked.
          var credential = result.credential;
          var user = result.user;
          // ...
        }
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });

      Web v9

      import { getRedirectResult } from "firebase/auth";
      getRedirectResult(auth).then((result) => {
        const credential = GoogleAuthProvider.credentialFromResult(result);
        if (credential) {
          // Accounts successfully linked.
          const user = result.user;
          // ...
        }
      }).catch((error) => {
        // Handle Errors here.
        // ...
      });
    Si el usuario accede correctamente, la cuenta de usuario correspondiente al proveedor se vincula con la cuenta del usuario en el proyecto de Firebase.

    La vinculación de cuentas fallará si ya se vincularon las credenciales con la cuenta de otro usuario. En esta situación, debes administrar la fusión de las cuentas y los datos asociados según corresponda para la app:

    Web v8

    // The implementation of how you store your user data depends on your application
    var repo = new MyUserDataRepo();
    
    // Get reference to the currently signed-in user
    var prevUser = auth.currentUser;
    
    // Get the data which you will want to merge. This should be done now
    // while the app is still signed in as this user.
    var prevUserData = repo.get(prevUser);
    
    // Delete the user's data now, we will restore it if the merge fails
    repo.delete(prevUser);
    
    // Sign in user with the account you want to link to
    auth.signInWithCredential(newCredential).then((result) => {
      console.log("Sign In Success", result);
      var currentUser = result.user;
      var currentUserData = repo.get(currentUser);
    
      // Merge prevUser and currentUser data stored in Firebase.
      // Note: How you handle this is specific to your application
      var mergedData = repo.merge(prevUserData, currentUserData);
    
      return prevUser.linkWithCredential(result.credential)
        .then((linkResult) => {
          // Sign in with the newly linked credential
          return auth.signInWithCredential(linkResult.credential);
        })
        .then((signInResult) => {
          // Save the merged data to the new user
          repo.set(signInResult.user, mergedData);
        });
    }).catch((error) => {
      // If there are errors we want to undo the data merge/deletion
      console.log("Sign In Error", error);
      repo.set(prevUser, prevUserData);
    });

    Web v9

    import { getAuth, signInWithCredential, linkWithCredential, OAuthProvider } from "firebase/auth";
    
    // The implementation of how you store your user data depends on your application
    const repo = new MyUserDataRepo();
    
    // Get reference to the currently signed-in user
    const auth = getAuth();
    const prevUser = auth.currentUser;
    
    // Get the data which you will want to merge. This should be done now
    // while the app is still signed in as this user.
    const prevUserData = repo.get(prevUser);
    
    // Delete the user's data now, we will restore it if the merge fails
    repo.delete(prevUser);
    
    // Sign in user with the account you want to link to
    signInWithCredential(auth, newCredential).then((result) => {
      console.log("Sign In Success", result);
      const currentUser = result.user;
      const currentUserData = repo.get(currentUser);
    
      // Merge prevUser and currentUser data stored in Firebase.
      // Note: How you handle this is specific to your application
      const mergedData = repo.merge(prevUserData, currentUserData);
    
      const credential = OAuthProvider.credentialFromResult(result);
      return linkWithCredential(prevUser, credential)
        .then((linkResult) => {
          // Sign in with the newly linked credential
          const linkCredential = OAuthProvider.credentialFromResult(linkResult);
          return signInWithCredential(auth, linkCredential);
        })
        .then((signInResult) => {
          // Save the merged data to the new user
          repo.set(signInResult.user, mergedData);
        });
    }).catch((error) => {
      // If there are errors we want to undo the data merge/deletion
      console.log("Sign In Error", error);
      repo.set(prevUser, prevUserData);
    });

Para agregar credenciales de dirección de correo electrónico y contraseña a una cuenta de usuario existente, haz lo siguiente:

  1. Permite que el usuario acceda mediante cualquier proveedor o método de autenticación.
  2. Pide al usuario que ingrese una dirección de correo electrónico y una contraseña nueva.
  3. Crea un objeto AuthCredential con la dirección de correo electrónico y la contraseña:

    Web v8

    var credential = firebase.auth.EmailAuthProvider.credential(email, password);

    Web v9

    import { EmailAuthProvider } from "firebase/auth";
    
    const credential = EmailAuthProvider.credential(email, password);
  4. Pasa el objeto AuthCredential al método linkWithCredential del usuario que accedió:

    Web v8

    auth.currentUser.linkWithCredential(credential)
      .then((usercred) => {
        var user = usercred.user;
        console.log("Account linking success", user);
      }).catch((error) => {
        console.log("Account linking error", error);
      });

    Web v9

    import { getAuth, linkWithCredential } from "firebase/auth";
    
    const auth = getAuth();
    linkWithCredential(auth.currentUser, credential)
      .then((usercred) => {
        const user = usercred.user;
        console.log("Account linking success", user);
      }).catch((error) => {
        console.log("Account linking error", error);
      });

    La llamada a linkWithCredential fallará si ya se vincularon las credenciales con la cuenta de otro usuario. En esta situación, debes administrar la fusión de las cuentas y los datos asociados según corresponda para la app (consulta los ejemplos anteriores).

Puedes desvincular un proveedor de autenticación de una cuenta para que el usuario ya no pueda acceder con ese proveedor.

Para desvincular un proveedor de autenticación de una cuenta de usuario, pasa el ID del proveedor al método unlink. Puedes obtener los ID de los proveedores de autenticación vinculados con un usuario desde la propiedad providerData.

Web v8

user.unlink(providerId).then(() => {
  // Auth provider unlinked from account
  // ...
}).catch((error) => {
  // An error happened
  // ...
});

Web v9

import { getAuth, unlink } from "firebase/auth";

const auth = getAuth();
unlink(auth.currentUser, providerId).then(() => {
  // Auth provider unlinked from account
  // ...
}).catch((error) => {
  // An error happened
  // ...
});