首先使用 Facebook 进行身份验证，然后使用 Google 进行身份验证会导致 Firebase for Android 出现错误

Question

正如我从Firebase Docs 中了解到的，如果用户使用凭据对其帐户进行身份验证，并且该凭据尚未与另一个凭据关联，则他应该严格使用相同的凭据登录。

换句话说，如果我使用 Google 登录创建一个帐户，然后（退出后）尝试使用与 Google 凭据相同的电子邮件使用 Facebook 凭据登录，我应该在 logcat 中看到此异常：

“已存在具有相同电子邮件地址但登录凭据不同的帐户。使用与此电子邮件地址关联的提供商登录。”

是的，我毫不奇怪地得到这个例外。 但是，如果我使用 Facebook 创建帐户，然后尝试使用 Google 凭据登录，则此帐户的提供者 (Facebook) 将转换为 Google。 这次认证没有失败，但不是预期的结果。 我想以某种方式将每个用户与特定凭据相关联。 我应该如何解决这个问题？ 你可以看到下面的代码：

public class SignInActivity extends AppCompatActivity implements GoogleApiClient.OnConnectionFailedListener,
        View.OnClickListener {

    private static final String TAG = "SignInActivity";
    private static final int RC_SIGN_IN = 9001;

    private GoogleApiClient mGoogleApiClient;
    private FirebaseAuth mFirebaseAuth;
    private FirebaseAuth.AuthStateListener mFirebaseAuthListener;

    private CallbackManager mCallbackManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_sign_in);

        // Facebook Login
        FacebookSdk.sdkInitialize(getApplicationContext());
        mCallbackManager = CallbackManager.Factory.create();

        LoginButton mFacebookSignInButton = (LoginButton) findViewById(R.id.facebook_login_button);
        mFacebookSignInButton.setReadPermissions("email", "public_profile");

        mFacebookSignInButton.registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
            @Override
            public void onSuccess(LoginResult loginResult) {
                Log.d(TAG, "facebook:onSuccess:" + loginResult);
                firebaseAuthWithFacebook(loginResult.getAccessToken());
            }

            @Override
            public void onCancel() {
                Log.d(TAG, "facebook:onCancel");
            }

            @Override
            public void onError(FacebookException error) {
                Log.d(TAG, "facebook:onError", error);
            }
        });

        // Google Sign-In
        // Assign fields
        SignInButton mGoogleSignInButton = (SignInButton) findViewById(R.id.google_sign_in_button);

        // Set click listeners
        mGoogleSignInButton.setOnClickListener(this);

        GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
                .requestIdToken(getString(R.string.default_web_client_id))
                .requestEmail()
                .build();
        mGoogleApiClient = new GoogleApiClient.Builder(this)
                .enableAutoManage(this /* FragmentActivity */, this /* OnConnectionFailedListener */)
                .addApi(Auth.GOOGLE_SIGN_IN_API, gso)
                .build();

        // Initialize FirebaseAuth
        mFirebaseAuth = FirebaseAuth.getInstance();

        mFirebaseAuthListener = new FirebaseAuth.AuthStateListener() {
            @Override
            public void onAuthStateChanged(@NonNull FirebaseAuth firebaseAuth) {
                FirebaseUser user = firebaseAuth.getCurrentUser();
                if (user != null) {
                    // User is signed in
                    Log.d(TAG, "onAuthStateChanged:signed_in:" + user.getUid());
                } else {
                    // User is signed out
                    Log.d(TAG, "onAuthStateChanged:signed_out");
                }
            }
        };
    }

    @Override
    public void onStart() {
        super.onStart();
        mFirebaseAuth.addAuthStateListener(mFirebaseAuthListener);
    }

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

    private void firebaseAuthWithGoogle(GoogleSignInAccount acct) {
        Log.d(TAG, "firebaseAuthWithGooogle:" + acct.getId());
        AuthCredential credential = GoogleAuthProvider.getCredential(acct.getIdToken(), null);
        mFirebaseAuth.signInWithCredential(credential)
                .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        Log.d(TAG, "signInWithCredential:onComplete:" + task.isSuccessful());

                        // If sign in fails, display a message to the user. If sign in succeeds
                        // the auth state listener will be notified and logic to handle the
                        // signed in user can be handled in the listener.
                        if (!task.isSuccessful()) {
                            Log.w(TAG, "signInWithCredential", task.getException());
                            Toast.makeText(SignInActivity.this, "Authentication failed.",
                                    Toast.LENGTH_SHORT).show();
                        } else {
                            startActivity(new Intent(SignInActivity.this, MainActivity.class));
                            finish();
                        }
                    }
                });
    }

    private void firebaseAuthWithFacebook(AccessToken token) {
        Log.d(TAG, "handleFacebookAccessToken:" + token);

        final AuthCredential credential = FacebookAuthProvider.getCredential(token.getToken());
        mFirebaseAuth.signInWithCredential(credential)
                .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        Log.d(TAG, "signInWithCredential:onComplete:" + task.isSuccessful());

                        // If sign in fails, display a message to the user. If sign in succeeds
                        // the auth state listener will be notified and logic to handle the
                        // signed in user can be handled in the listener.
                        if (!task.isSuccessful()) {
                            Log.w(TAG, "signInWithCredential", task.getException());
                            Toast.makeText(SignInActivity.this, "Authentication failed.",
                                    Toast.LENGTH_SHORT).show();
                        }

                        else {
                            startActivity(new Intent(SignInActivity.this, MainActivity.class));
                            finish();
                        }
                    }
                });
    }

    /*
    private void handleFirebaseAuthResult(AuthResult authResult) {
        if (authResult != null) {
            // Welcome the user
            FirebaseUser user = authResult.getUser();
            Toast.makeText(this, "Welcome " + user.getEmail(), Toast.LENGTH_SHORT).show();

            // Go back to the main activity
            startActivity(new Intent(this, MainActivity.class));
        }
    }
    */

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.google_sign_in_button:
                signIn();
                break;
            default:
                return;
        }
    }

    private void signIn() {
        Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(mGoogleApiClient);
        startActivityForResult(signInIntent, RC_SIGN_IN);
    }

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

        mCallbackManager.onActivityResult(requestCode, resultCode, data);

        // Result returned from launching the Intent from GoogleSignInApi.getSignInIntent(...);
        if (requestCode == RC_SIGN_IN) {
            GoogleSignInResult result = Auth.GoogleSignInApi.getSignInResultFromIntent(data);
            if (result.isSuccess()) {
                // Google Sign In was successful, authenticate with Firebase
                GoogleSignInAccount account = result.getSignInAccount();
                firebaseAuthWithGoogle(account);
            } else {
                // Google Sign In failed
                Log.e(TAG, "Google Sign In failed.");
            }
        }
    }

    @Override
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
        // An unresolvable error has occurred and Google APIs (including Sign-In) will not
        // be available.
        Log.d(TAG, "onConnectionFailed:" + connectionResult);
        Toast.makeText(this, "Google Play Services error.", Toast.LENGTH_SHORT).show();
    }
}

Answer 1

转到Authentication > Sign-in providers ，单击每个电子邮件地址的多个帐户，并允许使用相同的电子邮件地址创建多个帐户是您要查找的。

Answer 2

请检查线程： https : //groups.google.com/forum/#!searchin /firebase-talk/ liu /firebase- talk /ms_NVQem_Cw/ 8g7BFk1IAAAJ它解释了为什么会发生这种情况。 这是由于 Google 电子邮件被验证存在一些安全问题，而 Facebook 电子邮件则没有。

Answer 3

我最终以这个逻辑结束：

如果用户尝试使用 Facebook 登录，但具有给定电子邮件的用户已存在（使用 Google 提供商）并且会发生此错误：

“已存在具有相同电子邮件地址但登录凭据不同的帐户。使用与此电子邮件地址关联的提供商登录。”

因此，只需要求用户使用 Google 登录（然后静默将 Facebook 链接到现有帐户）

Answer 4

为了在不影响帐户安全的情况下最大限度地减少登录 UI 的点击次数，Firebase 身份验证有一个“可信提供者”的概念，其中身份提供者也是电子邮件服务提供者。 例如，Google 是@gmail.com 地址的可信提供商，Yahoo 是@yahoo.com 地址的可信提供商，Microsoft 是@outlook.com 地址的可信提供商。

在“每个电子邮件地址一个帐户”模式下，Firebase 身份验证尝试根据电子邮件地址关联帐户。 如果用户从受信任的提供商登录，用户会立即登录帐户，因为我们知道用户拥有电子邮件地址。

如果存在具有相同电子邮件地址但使用不受信任的凭据（例如不受信任的提供商或密码）创建的现有帐户，则出于安全原因删除先前的凭据。 网络钓鱼者（不是电子邮件地址所有者）可能会创建初始帐户 - 删除初始凭据将阻止网络钓鱼者随后访问该帐户。

刘金

Answer 5

在 firebase 中，通过发送验证电子邮件来验证用户首次登录 Facebook 时的电子邮件帐户非常重要。

验证电子邮件后，如果用户使用@gmail.com 作为电子邮件地址，您可以同时使用 Facebook 和 Gmail 登录。

Facebook 登录 -> 单击验证电子邮件中的链接 -> Gmail 登录 -> Facebook 登录（确定）

Facebook 登录 -> Gmail 登录 -> 单击验证电子邮件中的链接 -> Facebook 登录（不正常）

如果您在用户注销前未验证 Facebook 电子邮件并尝试使用他们的 gmail 登录，则当他们使用他们的 gmail 登录时，您将无法再次使用 Facebook 登录。

更新 - 如果您选择始终信任 Facebook 电子邮件。

您可以设置一个 firebase 函数（触发器），当第一次通过 Facebook 帐户登录时，它会自动将 emailVerified 设置为 true。

示例代码。

const functions = require('firebase-functions');
const admin = require('firebase-admin');

exports.app = functions.auth.user().onCreate( async (user) => {

  if (user.providerData.find(d => d && d.providerId === 'facebook.com') || user.providerData === 'facebook.com') {
    
      try {
      await admin.auth().updateUser(user.uid, {
          emailVerified: true
        })
      } catch (err) {
        console.log('err when verifying email', err)
      }
  }
})

文档： Firebase 身份验证触发器

Answer 6

我有同样的问题。 所以我删除了谷歌账户和脸书账户

firebase 控制台 > 身份验证 > 用户

您曾经在相互测试之前登录。

Answer 7

正如有人特别写的，Facebook 用户需要电子邮件验证以及电子邮件和密码（提供商 = 密码）。

我想如果用户使用谷歌电子邮件，它会自动获得验证状态。

谷歌应该解决的问题：

如果用户先通过Facebook登录，然后通过Gmail登录，则未完成电子邮件验证的帐户将被写入。 后来的电子邮件验证没有改变任何东西，帐户被覆盖

如果用户通过 Facebook 登录并验证电子邮件（gmail），那么每个想法都可以。 可以使用两个社交媒体提供商登录

Answer 8

允许使用相同的电子邮件地址创建多个帐户正是您所需要的。

仅当您在后端检查电子邮件并且这是您的用户的参考时，才可以正常工作。 如果您使用 Firebase Id，则无法保留唯一用户。

Answer 9

我遇到了同样的问题，您所要做的就是转到 Firebase 控制台，然后在“身份验证”类别中删除您想要的用户。

这对我有用。