如何从Android应用程序中删除Firebase用户？

我试图在我的Android应用程序中编写一个Delete User方法，但每次执行时都会遇到一些问题。当用户按下“活动”上的“删除帐户”按钮时，将执行此方法。我的应用程序与FirebaseUI Auth配合使用

方法如下：

private void deleteCount（）{
Log.d（标记为“进入删除帐户”）；
FirebaseAuth FirebaseAuth=FirebaseAuth.getInstance（）；
最终FirebaseUser currentUser=firebaseAuth.getCurrentUser（）；
currentUser.delete（）.addOnCompleteListener（新的OnCompleteListener（））{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
Log.d（标记“OK！工作正常！”）；
startActivity（新意图（Main3WelcomeActivity.this，Main3Activity.class））；
完成（）；
} 
}
}).addOnFailureListener（新的OnFailureListener（）{
@凌驾
public void onFailure（@NonNull异常e）{
Log.e（标签“Ocurrio un error durante la eliminación del usuario”，e）；
}
});
}

1） 当我执行该功能时，屏幕上会显示一条智能锁定消息，用户将再次登录。以下是此消息的屏幕截图

2） 在其他情况下，当用户长时间登录时，函数会引发如下异常：

06-30 00:01:26.672 11152-11152/com.devpicon.android.firebasesamples E/Main3WelcomeActivity: Ocurrio un error durante la eliminación del usuario
com.google.firebase.FirebaseException: An internal error has occured. [ CREDENTIAL_TOO_OLD_LOGIN_AGAIN ]
at com.google.android.gms.internal.zzacq.zzbN(Unknown Source)
at com.google.android.gms.internal.zzacn$zzg.zza(Unknown Source)
at com.google.android.gms.internal.zzacy.zzbO(Unknown Source)
at com.google.android.gms.internal.zzacy$zza.onFailure(Unknown Source)
at com.google.android.gms.internal.zzact$zza.onTransact(Unknown Source)
at android.os.Binder.execTransact(Binder.java:453)

我已经阅读了该用户的信息，但我不确定在使用Google登录时如何执行此操作。

使用以下方法：-

删除（）

相当于调用

set（null）

或

removeUser（）

---

根据

Firebase

文档，用户可以使用

delete（）

方法将用户从Firebase

在删除用户之前，请重新验证该用户

示例代码

GoogleAuthProvider.getCredential(googleIdToken,null);

---

您的

delete

回调已经处理了失败的情况，为什么要稍后添加

addOnFailureListener

尝试删除它，方法如下：

private void deleteAccount() {
    Log.d(TAG, "ingreso a deleteAccount");
    FirebaseAuth firebaseAuth = FirebaseAuth.getInstance();
    final FirebaseUser currentUser = firebaseAuth.getCurrentUser();
    currentUser.delete().addOnCompleteListener(new OnCompleteListener<Void>() {
        @Override
        public void onComplete(@NonNull Task<Void> task) {
            if (task.isSuccessful()) {
                Log.d(TAG,"OK! Works fine!");
                startActivity(new Intent(Main3WelcomeActivity.this, Main3Activity.class));
                finish();
            } else {
                Log.w(TAG,"Something is wrong!");
            }
        }
    });
}

private void deleteCount（）{
Log.d（标记为“进入删除帐户”）；
FirebaseAuth FirebaseAuth=FirebaseAuth.getInstance（）；
最终FirebaseUser currentUser=firebaseAuth.getCurrentUser（）；
currentUser.delete（）.addOnCompleteListener（新的OnCompleteListener（））{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
Log.d（标记“OK！工作正常！”）；
startActivity（新意图（Main3WelcomeActivity.this，Main3Activity.class））；
完成（）；
}否则{
Log.w（标记“有问题！”）；
}
}
});
}

首先，您需要在用户登录时存储身份验证令牌或密码。如果你的应用程序没有提供谷歌登录、Facebook登录或其他功能，你只需要存储密码

//If there's any, delete all stored content from this user on Real Time Database. 
yourDatabaseReferenceNode.removeValue();

//Getting the user instance.
final FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();

if (user != null) {
    //You need to get here the token you saved at logging-in time.
    String token = "userSavedToken";
    //You need to get here the password you saved at logging-in time.
    String password = "userSavedPassword";

    AuthCredential credential;

    //This means you didn't have the token because user used like Facebook Sign-in method.
    if (token == null) {
       credential = EmailAuthProvider.getCredential(user.getEmail(), password);
    } else {
       //Doesn't matter if it was Facebook Sign-in or others. It will always work using GoogleAuthProvider for whatever the provider.
       credential = GoogleAuthProvider.getCredential(token, null);
    }

    //We have to reauthenticate user because we don't know how long 
    //it was the sign-in. Calling reauthenticate, will update the 
    //user login and prevent FirebaseException (CREDENTIAL_TOO_OLD_LOGIN_AGAIN) on user.delete()
    user.reauthenticate(credential)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                    @Override
                    public void onComplete(@NonNull Task<Void> task) {
                        //Calling delete to remove the user and wait for a result.
                        user.delete().addOnCompleteListener(new OnCompleteListener<Void>() {
                            @Override
                            public void onComplete(@NonNull Task<Void> task) {
                                if (task.isSuccessful()) {
                                    //Ok, user remove
                                } else {
                                    //Handle the exception
                                    task.getException();
                                }
                            }
                        });
                    }
                });    
}        

//如果有，请删除实时数据库中此用户的所有存储内容。
yourDatabaseReferenceNode.removeValue（）；
//获取用户实例。
最终FirebaseUser用户=FirebaseAuth.getInstance（）.getCurrentUser（）；
如果（用户！=null）{
//您需要在此处获取登录时保存的令牌。
String token=“userSavedToken”；
//您需要在此处获取登录时保存的密码。
String password=“userSavedPassword”；
认证证书；
//这意味着您没有令牌，因为用户使用了Facebook登录方法。
if（标记==null）{
credential=EmailAuthProvider.getCredential（user.getEmail（），密码）；
}否则{
//无论是Facebook登录还是其他登录，它都会使用GoogleAuthProvider为任何提供商提供服务。
credential=GoogleAuthProvider.getCredential（令牌，null）；
}
//我们必须重新验证用户，因为我们不知道需要多长时间
//这是登录。调用重新验证将更新
//用户登录并在用户上防止FirebaseException（凭据\u太旧\u再次登录）。删除（）
用户重新验证（凭证）
.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
//正在调用delete以删除用户并等待结果。
user.delete（）.addOnCompleteListener（新的OnCompleteListener（））{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
//好的，用户删除
}否则{
//处理异常
task.getException（）；
}
}
});
}
});    
}        

Ansuita Jr.提供的答案解释得非常漂亮，只需一个小问题就可以正确回答。 即使没有成功的重新身份验证，用户也会被删除。 这是因为我们使用

user.delete（）

在始终执行的onComplete（）方法中。 因此，我们需要添加一个if检查来检查任务是否成功，如下所述

user.reauthenticate(credential)
          .addOnCompleteListener(new OnCompleteListener<Void>() {
             @Override
             public void onComplete(@NonNull Task<Void> task) {
                 if (task.isSuccessful()) {
                    Log.e("TAG", "onComplete: authentication complete");
                    user.delete()
                    .addOnCompleteListener (new OnCompleteListener<Void>() {
                           @Override
                           public void onComplete(@NonNull Task<Void> task) {
                                if (task.isSuccessful()) {
                                    Log.e("TAG", "User account deleted.");
                                } else {
                                    Log.e("TAG", "User account deletion unsucessful.");
                                }
                          }
                     });
                 } else {
                     Toast.makeText(UserProfileActivity.this, "Authentication failed", 
                               Toast.LENGTH_SHORT).show();
                 }
              }
         });

user.reauthenticate（凭证）
.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
if（task.issusccessful（））{
Log.e（“TAG”、“onComplete:authentication complete”）；
user.delete（）
.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
如果（任务）
//If there's any, delete all stored content from this user on Real Time Database. 
yourDatabaseReferenceNode.removeValue();

//Getting the user instance.
final FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser();

if (user != null) {
    //You need to get here the token you saved at logging-in time.
    String token = "userSavedToken";
    //You need to get here the password you saved at logging-in time.
    String password = "userSavedPassword";

    AuthCredential credential;

    //This means you didn't have the token because user used like Facebook Sign-in method.
    if (token == null) {
       credential = EmailAuthProvider.getCredential(user.getEmail(), password);
    } else {
       //Doesn't matter if it was Facebook Sign-in or others. It will always work using GoogleAuthProvider for whatever the provider.
       credential = GoogleAuthProvider.getCredential(token, null);
    }

    //We have to reauthenticate user because we don't know how long 
    //it was the sign-in. Calling reauthenticate, will update the 
    //user login and prevent FirebaseException (CREDENTIAL_TOO_OLD_LOGIN_AGAIN) on user.delete()
    user.reauthenticate(credential)
            .addOnCompleteListener(new OnCompleteListener<Void>() {
                    @Override
                    public void onComplete(@NonNull Task<Void> task) {
                        //Calling delete to remove the user and wait for a result.
                        user.delete().addOnCompleteListener(new OnCompleteListener<Void>() {
                            @Override
                            public void onComplete(@NonNull Task<Void> task) {
                                if (task.isSuccessful()) {
                                    //Ok, user remove
                                } else {
                                    //Handle the exception
                                    task.getException();
                                }
                            }
                        });
                    }
                });    
}        

user.reauthenticate(credential)
          .addOnCompleteListener(new OnCompleteListener<Void>() {
             @Override
             public void onComplete(@NonNull Task<Void> task) {
                 if (task.isSuccessful()) {
                    Log.e("TAG", "onComplete: authentication complete");
                    user.delete()
                    .addOnCompleteListener (new OnCompleteListener<Void>() {
                           @Override
                           public void onComplete(@NonNull Task<Void> task) {
                                if (task.isSuccessful()) {
                                    Log.e("TAG", "User account deleted.");
                                } else {
                                    Log.e("TAG", "User account deletion unsucessful.");
                                }
                          }
                     });
                 } else {
                     Toast.makeText(UserProfileActivity.this, "Authentication failed", 
                               Toast.LENGTH_SHORT).show();
                 }
              }
         });

user.delete();

 AuthUI.getInstance().delete(context).addOnSuccessListener {
           
 }.addOnFailureListener{

 }

FirebaseAuth.getInstance().currentUser.delete().addOnSuccessListener...