O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Vincular vários provedores de autenticação a uma conta usando JavaScript

Ao vincular as credenciais de provedores de autenticação a contas de usuário existentes, você permite que esses usuários façam login no seu app usando diferentes provedores. O ID do Firebase identifica usuários de qualquer provedor de autenticação. Por exemplo, um usuário que fez login com uma senha pode vincular uma Conta do Google e usar um desses métodos. Ou um usuário anônimo pode vincular uma conta do Facebook para acessar o app.

Antes de começar

Adicione ao app o suporte para dois ou mais provedores de autenticação, possivelmente incluindo autenticação anônima.

Siga estas etapas para vincular credenciais de um provedor de autenticação, como o Google ou Facebook, a uma conta de usuário existente:

  1. Faça login usando qualquer provedor ou método de autenticação.
  2. Consiga o objeto AuthProvider que corresponde ao provedor que você quer vincular à conta do usuário. Exemplos: 
    var googleProvider = new firebase.auth.GoogleAuthProvider();
var facebookProvider = new firebase.auth.FacebookAuthProvider();
var twitterProvider = new firebase.auth.TwitterAuthProvider();
var githubProvider = new firebase.auth.GithubAuthProvider();
    link-multiple-accounts.js
  3. Solicite que o usuário faça login com o provedor que você quer vincular. Você pode solicitar que os usuários façam login em uma janela pop-up ou redirecionando-os à página de login do provedor. O método de redirecionamento é recomendável para dispositivos móveis.
    • Para fazer login com uma janela pop-up, chame linkWithPopup: 
      auth.currentUser.linkWithPopup(provider).then(function(result) {
  // Accounts successfully linked.
  var credential = result.credential;
  var user = result.user;
  // ...
}).catch(function(error) {
  // Handle Errors here.
  // ...
});
      link-multiple-accounts.js
    • Para fazer login com um redirecionamento à página de login do provedor, chame linkWithRedirect: 
      auth.currentUser.linkWithRedirect(provider)
  .then(/* ... */)
  .catch(/* ... */);
      link-multiple-accounts.js
      Depois que o usuário fizer login, ele será redirecionado à sua página. Em seguida, recupere o resultado do login chamando getRedirectResult quando a página for carregada: 
      auth.getRedirectResult().then(function(result) {
  if (result.credential) {
    // Accounts successfully linked.
    var credential = result.credential;
    var user = result.user;
    // ...
  }
}).catch(function(error) {
  // Handle Errors here.
  // ...
});
      link-multiple-accounts.js
    Se o usuário fizer login corretamente, a conta dele com o provedor ficará vinculada à conta do usuário no seu projeto do Firebase.

    A vinculação de contas falhará se as credenciais já estiverem vinculadas a outra conta de usuário. Nesse caso, você precisará mesclar as contas e os dados associados da maneira apropriada para o app:

    // 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(function(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(function(linkResult) {
      // Sign in with the newly linked credential
      return auth.signInWithCredential(linkResult.credential);
    })
    .then(function(signInResult) {
      // Save the merged data to the new user
      repo.set(signInResult.user, mergedData);
    });
}).catch(function(error) {
  // If there are errors we want to undo the data merge/deletion
  console.log("Sign In Error", error);
  repo.set(prevUser, prevUserData);
});
    link-multiple-accounts.js

Siga estas etapas para adicionar credenciais de endereço de e-mail e senha a uma conta existente:

  1. Faça login usando qualquer provedor ou método de autenticação.
  2. Solicite que o usuário insira e-mail e uma nova senha.
  3. Crie um objeto AuthCredential com o endereço de e-mail e a senha: 
    var credential = firebase.auth.EmailAuthProvider.credential(email, password);
    link-multiple-accounts.js

  4. Transmita o objeto AuthCredential ao método linkWithCredential do usuário conectado:

    auth.currentUser.linkWithCredential(credential)
  .then(function(usercred) {
    var user = usercred.user;
    console.log("Account linking success", user);
  }).catch(function(error) {
    console.log("Account linking error", error);
  });
    link-multiple-accounts.js

    A chamada para linkWithCredential falhará se as credenciais já estiverem vinculadas a outra conta de usuário. Nessa situação, você precisa lidar com a mesclagem das contas e dos dados associados conforme apropriado para seu app (veja o exemplo acima).

É possível desvincular um provedor de autenticação de uma conta para que o usuário não faça mais login com ele.

Para desvincular um provedor de autenticação de uma conta de usuário, transmita o ID dele ao método unlink. Consiga esses IDs dos provedores de autenticação vinculados a um usuário usando a propriedade providerData.

user.unlink(providerId).then(function() {
  // Auth provider unlinked from account
  // ...
}).catch(function(error) {
  // An error happened
  // ...
});
link-multiple-accounts.js