Android观察者模式和数据绑定，更改布尔属性时启动活动

因此，我有一个使用firebase login的登录活动和viewModel，我也在使用它的数据绑定，我一直在试图找到一种方法，让我的mainActivity在登录方法完成它的工作后运行，但我还没有找到某种方法。任何帮助或建议都将不胜感激，谢谢

这是我的登录活动：

public class LoginActivity extends AppCompatActivity implements Observer<String>{

    private LoginViewModel loginViewModel;
    private ActivityLoginBinding loginBinding;

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

        loginBinding = DataBindingUtil.setContentView(this,
                R.layout.activity_login);
        loginViewModel = new LoginViewModel();
        loginBinding.setVModel(loginViewModel);
        loginBinding.setActivity(this);

    }

    public void login(){
        String email = loginBinding.emailLginText.getText().toString();
        String password = loginBinding.pwLginTxt.getText().toString();

        loginViewModel.firebaseEmailAndPasswordAuth(email, password);

        if (loginViewModel.isAuthDone()){
            Intent sendToMain = new Intent(this, MainActivity.class);
            startActivity(sendToMain);
            finish();
        }
    }

    public void startSignUpActivity(){
        Intent sendToSignUp = new Intent(this, SignUpActivity.class);
        startActivity(sendToSignUp);
    }

    @Override
    protected void onResume() {
        super.onResume();
        loginViewModel.addObserver(this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        loginViewModel.removeObserver(this);
    }

    @Override
    public void onObserve(int event, String eventMessage) {

        if (event == MyUtils.SHOW_TOAST) {
            Toast.makeText(this, eventMessage, Toast.LENGTH_SHORT).show();
        } else if (event == MyUtils.OPEN_ACTIVITY){

        }
    }
}

公共类LoginActivity扩展了AppCompatActivity实现了Observer{
私人LoginView模型LoginView模型；
私人活动登录绑定登录绑定；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
loginBinding=DataBindingUtil.setContentView（此，
R.布局、活动（用户登录）；
loginViewModel=新loginViewModel（）；
loginBinding.setVModel（loginViewModel）；
loginBinding.setActivity（此）；
}
公共无效登录（）{
字符串email=loginBinding.emailLginText.getText（）.toString（）；
字符串密码=loginBinding.pwlginText.getText（）.toString（）；
loginViewModel.firebaseEmailAndPasswordAuth（电子邮件，密码）；
if（loginViewModel.isAuthDone（））{
Intent sendToMain=新的Intent（这个，MainActivity.class）；
星触觉（sendToMain）；
完成（）；
}
}
public void startSignUpActivity（）{
Intent sendToSignUp=newintent（这是SignUpActivity.class）；
startActivity（sendToSignUp）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
loginViewModel.addObserver（本）；
}
@凌驾
受保护的void onPause（）{
super.onPause（）；
loginViewModel.removeObserver（此）；
}
@凌驾
public void onObserve（int事件、String事件消息）{
if（event==MyUtils.SHOW\u TOAST）{
Toast.makeText（this，eventMessage，Toast.LENGTH_SHORT）.show（）；
}else if（event==MyUtils.OPEN\u活动）{
}
}
}

我的viewModel：

public class LoginViewModel extends BaseObservable {

    private boolean isAuthDone;
    private boolean isAuthInProgress;
    private ArrayList<Observer> observers;
    public Context mContext;


    public LoginViewModel(){
        observers = new ArrayList<>();
    }

    @Bindable
    public boolean isAuthDone(){
        return isAuthDone;
    }

    private void setAuthDone(boolean authDone){
        isAuthDone = authDone;
        notifyPropertyChanged(BR.authDone);
    }

    @Bindable
    public boolean isAuthInProgress(){
        return isAuthInProgress;
    }

    private void setAuthInProgress(boolean authInProgress){
        isAuthInProgress = authInProgress;
        notifyPropertyChanged(BR.authInProgress);
    }

    public boolean isEmailAndPassValid(String email, String password){

        if (TextUtils.isEmpty(email))
            return false;
        if (!MyUtils.isEmailValid(email))
            return false;
        return !TextUtils.isEmpty(password);
    }

    public void firebaseEmailAndPasswordAuth(String email, String password){
        setAuthInProgress(true);

        FirebaseAuth.getInstance().signInWithEmailAndPassword(email, password)
                .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        setAuthInProgress(false);

                        if (task.isSuccessful()) {
                            setAuthDone(true);

                        } else {
                            notifyObservers(MyUtils.SHOW_TOAST, MyUtils.MESSAGE_AUTHENTICATION_FAILED);
                        }
                    }
                });
    }

    public void addObserver(Observer client) {
        if (!observers.contains(client)) {
            observers.add(client);
        }
    }

    public void removeObserver(Observer clientToRemove) {

        observers.remove(clientToRemove);
    }

    private void notifyObservers(int eventType, String message) {
        for (int i=0; i< observers.size(); i++) {
            observers.get(i).onObserve(eventType, message);
        }
    }

}

公共类LoginViewModel扩展了BaseObservable{
私有布尔isAuthDone；
私有布尔isAuthInProgress；
私人ArrayList观察员；
公共语境；
公共登录视图模型（）{
Observators=新的ArrayList（）；
}
@装订的
公共布尔值isAuthDone（）{
返回isAuthDone；
}
私有void setAuthDone（布尔authDone）{
isAuthDone=authDone；
notifyPropertyChanged（BR.authDone）；
}
@装订的
公共布尔值isAuthInProgress（）{
返回isAuthInProgress；
}
私有void setAuthInProgress（布尔authInProgress）{
isAuthInProgress=authInProgress；
notifyPropertyChanged（BR.authInProgress）；
}
公共布尔值isEmailAndPassValid（字符串电子邮件、字符串密码）{
如果（TextUtils.isEmpty（电子邮件））
返回false；
如果（！MyUtils.isEmailValid（电子邮件））
返回false；
return！TextUtils.isEmpty（密码）；
}
public void firebaseEmailAndPasswordAuth（字符串电子邮件，字符串密码）{
setAuthInProgress（真）；
FirebaseAuth.getInstance（）.signInWithEmailAndPassword（电子邮件，密码）
.addOnCompleteListener（新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
setAuthInProgress（假）；
if（task.issusccessful（））{
setAuthDone（真）；
}否则{
notifyObservers（MyUtils.SHOW\u TOAST、MyUtils.MESSAGE\u身份验证\u失败）；
}
}
});
}
public void addObserver（观察者客户端）{
如果（！observators.contains（客户端））{
添加（客户）；
}
}
public void removeObserver（观察者客户端删除）{
观察者。移除（客户端删除）；
}
私有void notifyObserver（int事件类型，字符串消息）{
对于（int i=0；i

和我的观察者界面：

public interface Observer<T>
{
        void onObserve(int event, T eventMessage);
}

公共接口观察者
{
void onObserve（int事件、T事件消息）；
}

如果您想知道用户何时登录，应该使用。在侦听器回调中，执行继续应用所需的任何操作。通常，在启动时添加一个，在启动时删除一个

这是代码的一般结构。您将希望使其适应您选择的任何体系结构：

private FirebaseAuth.AuthStateListener authStateListener = new FirebaseAuth.AuthStateListener() {
    public void onAuthStateChanged(FirebaseAuth auth) {
        //  Check if user is signed in and do what you want
    }
}

protected void onStart() {
    // ...
    FirebaseAuth.getInstance().addAuthStateListener(authStateListener);
}

protected void onStop() {
    // ...
    FirebaseAuth.getInstance().removeAuthStateListener(authStateListener);
}

---

Android已经为您准备好了这样的字段：使用附带的OnPropertyChangedCallback。这解决了我的问题，并清理了大量代码