Android Firebase在注册前验证用户

我想在允许注册之前验证一个用户，但是，即使数据正确，验证在第一次调用时也总是失败

private var isAprroved : Boolean = false

fun signUp(email: String, password: String, idNumber: String): Task<AuthResult>? {
        verifyApprovedUser(idNumber)
        return if (isAprroved) {
            firebaseAuth.createUserWithEmailAndPassword(email, password)
        } else {
            null
        }
    }

    private fun verifyApprovedUser(idNumber: String) {
        dbRef.addListenerForSingleValueEvent(object : ValueEventListener {
            override fun onDataChange(snapshot: DataSnapshot) {
                if (snapshot.child(idNumber).exists()) {
                   updateUserVerified()
                }
            }

            override fun onCancelled(error: DatabaseError) {
                TODO("Not yet implemented")
            }

        })

    }

    fun updateUserVerified() {
        isAprroved = true
    } 

private var已批准：布尔值=false
有趣的注册（电子邮件：String，密码：String，idNumber:String）：任务？{
验证ApprovedUser（idNumber）
如果已批准，则返回{
firebaseAuth.createUserWithEmailAndPassword（电子邮件，密码）
}否则{
无效的
}
}
private fun verifyApprovedUser（idNumber:String）{
dbRef.addListenerForSingleValueEvent（对象：ValueEventListener{
覆盖数据更改（快照：DataSnapshot）{
if（snapshot.child（idNumber.exists（））{
UpdateUserified（）
}
}
覆盖已取消（错误：DatabaseError）{
TODO（“尚未实施”）
}
})
}
乐趣更新服务器化（）{
Isaproved=真
} 

已批准

始终为

false

，因为

verifyApprovedUser

函数调用异步函数，因此

createUserWithEmailAndPassword

将在

onDataChange

函数之前调用

要解决此问题，您必须更改

verifyApprovedUser

以返回

Task

，并在

signUp

函数中使用

continueWithTask

进行链接，如下所示。（不过我没有测试代码）

Kotlin版本：

private fun signUp(email: String, password: String, idNumber: String): Task<AuthResult?> {
    return verifyApprovedUser(idNumber).continueWithTask { task ->
        if (!task.isSuccessful) {
            return@continueWithTask Tasks.forException<AuthResult?>(task.exception!!)
        }
        val verified: Boolean = task.result
        if (verified) {
            return@continueWithTask FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, password)
        } else {
            return@continueWithTask Tasks.forResult<AuthResult?>(null)
        }
    }
}

private fun verifyApprovedUser(idNumber: String): Task<Boolean> {
    val tcs: TaskCompletionSource<Boolean> = TaskCompletionSource()
    FirebaseDatabase.getInstance().reference.addListenerForSingleValueEvent(object : ValueEventListener {
        override fun onDataChange(dataSnapshot: DataSnapshot) {
            val verified = dataSnapshot.child(idNumber).exists()
            tcs.setResult(verified)
        }

        override fun onCancelled(databaseError: DatabaseError) {
            tcs.setException(databaseError.toException())
        }
    })
    return tcs.task
}  

private Task<AuthResult> signUp(String email, String password, String idNumber) {
    return verifyApprovedUser(idNumber).continueWithTask(task -> {
        if (!task.isSuccessful()) {
            return Tasks.forException(task.getException());
        }
        boolean verified = task.getResult();
        if (verified) {
            return FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, password);
        } else {
            return Tasks.forResult(null);
        }
    });
}

private Task<Boolean> verifyApprovedUser(String idNumber) {
    TaskCompletionSource<Boolean> tcs = new TaskCompletionSource<>();
    FirebaseDatabase.getInstance().getReference().addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
            boolean verified = dataSnapshot.child(idNumber).exists();
            tcs.setResult(verified);
        }

        @Override
        public void onCancelled(@NonNull DatabaseError databaseError) {
            tcs.setException(databaseError.toException());
        }
    });
    return tcs.getTask();
}

private-fun注册（电子邮件：String，密码：String，idNumber:String）：任务{
返回verifyApprovedUser（idNumber）。继续执行任务{task->
如果（！task.isSuccessful）{
return@continueWithTaskTasks.forException（task.exception！！）
}
val已验证：布尔值=task.result
如果（已验证）{
return@continueWithTaskFirebaseAuth.getInstance（）.createUserWithEmailAndPassword（电子邮件，密码）
}否则{
return@continueWithTaskTasks.forResult（空）
}
}
}
private fun verifyApprovedUser（idNumber:String）：任务{
val tcs:TaskCompletionSource=TaskCompletionSource（）
FirebaseDatabase.getInstance（）.reference.addListenerForSingleValueEvent（对象：ValueEventListener{
覆盖数据更改（dataSnapshot:dataSnapshot）{
val verified=dataSnapshot.child（idNumber）.exists（）
tcs.setResult（已验证）
}
覆盖已取消（databaseError:databaseError）{
setException（databaseError.toException（））
}
})
返回tcs.task
}  

Java版本：

private fun signUp(email: String, password: String, idNumber: String): Task<AuthResult?> {
    return verifyApprovedUser(idNumber).continueWithTask { task ->
        if (!task.isSuccessful) {
            return@continueWithTask Tasks.forException<AuthResult?>(task.exception!!)
        }
        val verified: Boolean = task.result
        if (verified) {
            return@continueWithTask FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, password)
        } else {
            return@continueWithTask Tasks.forResult<AuthResult?>(null)
        }
    }
}

private fun verifyApprovedUser(idNumber: String): Task<Boolean> {
    val tcs: TaskCompletionSource<Boolean> = TaskCompletionSource()
    FirebaseDatabase.getInstance().reference.addListenerForSingleValueEvent(object : ValueEventListener {
        override fun onDataChange(dataSnapshot: DataSnapshot) {
            val verified = dataSnapshot.child(idNumber).exists()
            tcs.setResult(verified)
        }

        override fun onCancelled(databaseError: DatabaseError) {
            tcs.setException(databaseError.toException())
        }
    })
    return tcs.task
}  

private Task<AuthResult> signUp(String email, String password, String idNumber) {
    return verifyApprovedUser(idNumber).continueWithTask(task -> {
        if (!task.isSuccessful()) {
            return Tasks.forException(task.getException());
        }
        boolean verified = task.getResult();
        if (verified) {
            return FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, password);
        } else {
            return Tasks.forResult(null);
        }
    });
}

private Task<Boolean> verifyApprovedUser(String idNumber) {
    TaskCompletionSource<Boolean> tcs = new TaskCompletionSource<>();
    FirebaseDatabase.getInstance().getReference().addListenerForSingleValueEvent(new ValueEventListener() {
        @Override
        public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
            boolean verified = dataSnapshot.child(idNumber).exists();
            tcs.setResult(verified);
        }

        @Override
        public void onCancelled(@NonNull DatabaseError databaseError) {
            tcs.setException(databaseError.toException());
        }
    });
    return tcs.getTask();
}

私人任务注册（字符串电子邮件、字符串密码、字符串idNumber）{
返回verifyApprovedUser（idNumber）。继续执行任务（任务->{
如果（！task.issusccessful（））{
返回Tasks.forException（task.getException（））；
}
布尔验证=task.getResult（）；
如果（已验证）{
返回FirebaseAuth.getInstance（）.createUserWithEmailAndPassword（电子邮件，密码）；
}否则{
返回Tasks.forResult（空）；
}
});
}
私有任务verifyApprovedUser（字符串idNumber）{
TaskCompletionSource tcs=新的TaskCompletionSource（）；
FirebaseDatabase.getInstance（）.getReference（）.addListenerForSingleValueEvent（新值EventListener（））{
@凌驾
public void onDataChange（@NonNull DataSnapshot DataSnapshot）{
已验证的布尔值=dataSnapshot.child（idNumber）.exists（）；
设置结果（已验证）；
}
@凌驾
已取消的公共void（@NonNull DatabaseError DatabaseError）{
setException（databaseError.toException（））；
}
});
返回tcs.getTask（）；
}

然而，推荐的方法是

RxJava

和Kotlin的

Coroutine

---

另外，您最好了解什么是反应式编程。

我不知道这有多高效，但这就是我如何实现的

 val approvedUsersList : MutableList<String> = ArrayList()

fun signUp(email: String, password: String, idNumber: String): Task<AuthResult>? {
        verifyApprovedUsers()
        if (idNumber in approvedUsersList){
           return firebaseAuth.createUserWithEmailAndPassword(email, password)
        } else {
            return null
        }
    }

    private fun verifyApprovedUsers() {
        dbRef.addListenerForSingleValueEvent(object : ValueEventListener {
            override fun onDataChange(snapshot: DataSnapshot) {
                approvedUsersList.clear()
                for (data: DataSnapshot in snapshot.children) {
                    approvedUsersList.add(data.value.toString())
                }

        }

val approvedUsersList:MutableList=ArrayList（）
有趣的注册（电子邮件：String，密码：String，idNumber:String）：任务？{
验证ApprovedUsers（）
if（approvedUsersList中的idNumber）{
返回firebaseAuth.createUserWithEmailAndPassword（电子邮件，密码）
}否则{
返回空
}
}
私人娱乐验证ApprovedUsers（）{
dbRef.addListenerForSingleValueEvent（对象：ValueEventListener{
覆盖数据更改（快照：DataSnapshot）{
approvedUsersList.clear（）
for（数据：snapshot.children中的DataSnapshot）{
approvedUsersList.add（data.value.toString（））
}
}

这是我的登录活动如何验证我以前是否已登录的方法

private fun verifyIfUserIsLoggedIn() { // Checks if user has already logged in
        val uid = FirebaseAuth.getInstance().uid

        // This checks if there is a present UID in your Activity
        // If UID == null, intent closes the CurrentActivity and throws you back in RegisterActivity
        if (uid == null) {
            val intent = Intent(this, RegisterActivity::class.java)
            intent.flags = Intent.FLAG_ACTIVITY_CLEAR_TASK.or(Intent.FLAG_ACTIVITY_NEW_TASK) // Clears previous activity when inflating the new one
            startActivity(intent)
        }
    }

---

您如何调用

signUp

？它应该在

updateServerified（）之后调用

@ADM我正在从视图模型调用sign up，它返回身份验证结果您可能在设置

isaproved

之前调用它。这两个方法调用应该是顺序的，因为

signUp

取决于

verifyApprovedUser

@ADM的输出。我如何确保firebaseAuth等待验证ApprovedUser的结果？？您检查了我的答案吗？我更新了答案，只需将java代码转换为kotlin:）我也更新了Kotlin版本，如果您有任何问题，请询问我。我尝试了该方法，但它不返回null，如果我尝试查询返回值的结果，我得到的任务不完整错误您是否找到了解决方法？如果您没有，我将测试代码并为您解决问题。此答案与O使用的语言不同P需要。P.s.对我来说仍然很好。如果你仍然不明白我是如何做到这一点的。只需在这里发表评论；）我不明白用户是怎么想的verified@Crucialjun对不起，兄弟，我发了