Java 当我'；我没有使用Firebase身份验证？

当用户在我的Android应用程序中注册时，他们的数据存储在一个集合中，其中文档ID是他们的电子邮件地址，有助于查找用户。密码也存储在文档中

因此，当用户登录时，他们输入的电子邮件将根据与该电子邮件匹配的文档ID进行检查，如果它存在，它将登录并显示用户控制面板

现在，在登录之后，我需要以某种方式创建一个用户会话，以便用户在注销之前不能返回登录屏幕。如果应用程序崩溃或失去网络连接，保存的用户会话将非常有用

以下是我的登录活动代码：

import android.content.Intent;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Patterns;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;

import com.basgeekball.awesomevalidation.AwesomeValidation;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.Task;
import com.google.firebase.firestore.CollectionReference;
import com.google.firebase.firestore.DocumentReference;
import com.google.firebase.firestore.DocumentSnapshot;
import com.google.firebase.firestore.FirebaseFirestore;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;

import static com.basgeekball.awesomevalidation.ValidationStyle.BASIC;

public class SLogin extends AppCompatActivity
{
public static final String STUDENT_EMAIL = "student_email";
private EditText tEmail;
private EditText tPassword;
private String email = "";

private FirebaseFirestore db = FirebaseFirestore.getInstance();
private CollectionReference dbUsers;

@Override
protected void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_slogin);

    tEmail= findViewById(R.id.Email);
    tEmail.addTextChangedListener(new TextWatcher()
    {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after)
        {

        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count)
        {
            email = s.toString();
        }

        @Override
        public void afterTextChanged(Editable s)
        {

        }
    });
    tPassword=findViewById(R.id.Password);

    // Here you simply set saveEmail to empty string because at this moment when activity is
    // created (onCreate) tEmail field is empty. To update this field dynamically you need set
    // addTextChangedListener on tEmail.
    // saveEmail=tEmail.getText().toString();

    dbUsers = db.collection("Students");
}

//Validation Method
private boolean validate()
{
    AwesomeValidation mAwesomeValidation = new AwesomeValidation(BASIC);
    mAwesomeValidation.addValidation(tEmail, Patterns.EMAIL_ADDRESS, "Invalid Email Address");
    String regexPassword = "(?=.*[a-z])(?=.*[A-Z])(?=.*[\\d])(?=.*[~`!@#\\$%\\^&\\*\\(\\)\\-_\\+=\\{\\}\\[\\]\\|\\;:\"<>,./\\?]).{6,}";
    mAwesomeValidation.addValidation(tPassword, regexPassword, "Use 6 or more characters with a mix of upper & lower letters, numbers & symbols");
    return mAwesomeValidation.validate();
}

//Method to check password matching or not
private void passCheck(@NonNull DocumentSnapshot snapshot)
{
    final String uPass = tPassword.getText().toString();
    final String storedPass = snapshot.getString("password");
    if (storedPass != null && storedPass.equals(uPass))
    {
        Intent intent = new Intent(SLogin.this, StudentCP.class);
        intent.putExtra(STUDENT_EMAIL, email);
        startActivity(intent);
    }
    else
    {
        Toast.makeText(SLogin.this, "Invalid Password!", Toast.LENGTH_LONG).show();
    }
}

public void sLogin(View v)
{
    if (validate())
    {
        DocumentReference dbDocs = dbUsers.document(email);
        dbDocs.get().addOnCompleteListener(new OnCompleteListener<DocumentSnapshot>()
        {
            @Override
            public void onComplete(@NonNull Task<DocumentSnapshot> task)
            {
                if (task.isSuccessful())
                {
                    DocumentSnapshot document = task.getResult();
                    if (document != null && document.exists())
                    {
                        //Toast.makeText(SLogin.this, "You are registered", Toast.LENGTH_LONG).show();

                        // Improved password checking because at first glance I
                        // don't see why you call db fetch again to get document
                        // because if we are here that means we got matching data
                        // and now we only need to check if password match. No need
                        // to call get on db again.
                        //
                        // It's possible to even more optimize calls to DB in case
                        // of wrongly typed password. We can cache input email and
                        // returned password for that email so in case if user
                        // doesn't change email, but types only password again we
                        // can compare newly typed password with cached password
                        // from previous request so we don't make again new DB
                        // request to simply get again same saved password.
                        //
                        // Currently I haven't implemented caching. It's only idea
                        // to think about in future.
                        passCheck(document);
                    }
                    else
                    {
                        Toast.makeText(SLogin.this, "You are not registered", Toast.LENGTH_LONG).show();
                    }
                }
                else
                {
                    Toast.makeText(SLogin.this, "Unable to connect to database", Toast.LENGTH_LONG).show();
                }
            }
        });
    }
}
public void nUser(View v)
{
    Intent intent = new Intent(SLogin.this, RegisterActivity.class);
    startActivity(intent);
}
}

导入android.content.Intent；
导入android.os.Bundle；
导入android.text.Editable；
导入android.text.TextWatcher；
导入android.util.Patterns；
导入android.view.view；
导入android.widget.EditText；
导入android.widget.Toast；
导入com.basgeekball.awesomevalidation.awesomevalidation；
导入com.google.android.gms.tasks.OnCompleteListener；
导入com.google.android.gms.tasks.Task；
导入com.google.firebase.firestore.CollectionReference；
导入com.google.firebase.firestore.DocumentReference；
导入com.google.firebase.firestore.DocumentSnapshot；
导入com.google.firebase.firestore.FirebaseFirestore；
导入androidx.annotation.NonNull；
导入androidx.appcompat.app.appcompat活动；
导入静态com.basgeekball.awesomevalidation.ValidationStyle.BASIC；
公共类SLogin扩展了AppCompative活动
{
公共静态最终字符串STUDENT\u EMAIL=“STUDENT\u EMAIL”；
私人编辑文本特梅尔；
私人编辑文本密码；
私人字符串email=“”；
私有FirebaseFirestore db=FirebaseFirestore.getInstance（）；
私人收藏参考数据库用户；
@凌驾
创建时受保护的void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity\u slogin）；
tEmail=findviewbyd（R.id.Email）；
tEmail.addTextChangedListener（新的TextWatcher（）
{
@凌驾
更改前文本之前的公共void（字符序列s、int start、int count、int after）
{
}
@凌驾
public void onTextChanged（字符序列、int start、int before、int count）
{
email=s.toString（）；
}
@凌驾
公共无效后文本已更改（可编辑）
{
}
});
tPassword=findviewbyd（R.id.Password）；
//在这里，您只需将saveEmail设置为空字符串，因为此时活动正在进行
//已创建（onCreate）临时邮件字段为空。若要动态更新此字段，需要设置
//在tEmail上添加TextChangedListener。
//saveEmail=tEmail.getText（）.toString（）；
dbUsers=db.collection（“学生”）；
}
//验证方法
私有布尔验证（）
{
AwesomeValidation mAwesomeValidation=新的AwesomeValidation（基本）；
mAwesomeValidation.addValidation（tEmail，Patterns.EMAIL_地址，“无效电子邮件地址”）；
字符串regexPassword=“（？=..[a-z]）（？=.[a-z]）（？=.[\\\\[\\\\[\\\\\$%\^&\\*\（\\\）\-\\\\\\\\\\\\[\\\\\]\\\\\\\\\\\[\\\\\\\\\\\\\\\\\\\\\\\\\\.[\\\\[\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\；
mAwesomeValidation.addValidation（tPassword、regexPassword，“使用6个或更多字符，并混合使用上下字母、数字和符号”）；
返回mAwesomeValidation.validate（）；
}
//方法来检查密码是否匹配
私有无效密码检查（@NonNull DocumentSnapshot snapshot）
{
最后一个字符串uPass=tPassword.getText（）.toString（）；
最终字符串storedPass=snapshot.getString（“密码”）；
if（storedPass！=null&&storedPass.equals（uPass））
{
意向意向=新意向（SLogin.this，StudentCP.class）；
意向书（学生电子邮件、电子邮件）；
星触觉（意向）；
}
其他的
{
Toast.makeText（SLogin.this，“无效密码！”，Toast.LENGTH_LONG.show（）；
}
}
公共空间斯洛金（视图五）
{
if（validate（））
{
DocumentReference dbDocs=dbUsers.document（电子邮件）；
dbDocs.get（）.addOnCompletListener（新的OnCompletListener（））
{
@凌驾
未完成的公共void（@NonNull任务）
{
if（task.issusccessful（））
{
DocumentSnapshot document=task.getResult（）；
if（document！=null&&document.exists（））
{
//Toast.makeText（SLogin.this，“您已注册”，Toast.LENGTH_LONG.show（）；
//改进了密码检查，因为乍一看我
//不明白为什么要再次调用db fetch来获取文档
//因为如果我们在这里，这意味着我们得到了匹配的数据
//现在我们只需要检查密码是否匹配。不需要
//再次调用get on db。
//
//在这种情况下，甚至可以优化对DB的调用
//密码输入错误。我们可以缓存输入的电子邮件和
//返回该电子邮件的密码，以防用户
//不会更改电子邮件，但只会再次键入密码
//可以将新键入的密码与缓存的密码进行比较
//从以前的请求中删除，这样我们就不会再创建新的数据库
//请求再次获取相同的已保存密码。
//
//目前我还没有实现缓存。这只是一个想法
//考虑将来。
通行证（文件）；
}
其他的
{
Toast.makeText（SLogin.this，“您未注册”，Toast.LENGTH_LONG.show（）；
}
}
其他的
{
Toast.makeText（SLogin.this，“无法
public class PrefUtilities {

private SharedPreferences preferences;
Context context;


private PrefUtilities(Context context) {
    preferences = PreferenceManager.getDefaultSharedPreferences(context);
    this.context = context;
}


public static PrefUtilities with(Context context){
    return new PrefUtilities(context);
}


public void setUserLogin(boolean isUserLogedin){

    preferences.edit().putBoolean(context.getString(R.string.pref_key_user_status),isUserLogedin).apply();

}

public boolean isUserLogedin(){
    return preferences.getBoolean(context.getString(R.string.pref_key_user_status),false);
}


}

if(PrefUtilities.with(this).isUserLogedin()){

   Intent intent = new Intent(SLogin.this, StudentCP.class);
        intent.putExtra(STUDENT_EMAIL, email);
        startActivity(intent);
}

private void passCheck(@NonNull DocumentSnapshot snapshot)
{
    final String uPass = tPassword.getText().toString();
    final String storedPass = snapshot.getString("password");
    if (storedPass != null && storedPass.equals(uPass))
    {

         PrefUtilities.with(this).setUserLogin(true);       

        Intent intent = new Intent(SLogin.this, StudentCP.class);
        intent.putExtra(STUDENT_EMAIL, email);
        startActivity(intent);
    }
    else
    {
        Toast.makeText(SLogin.this, "Invalid Password!", Toast.LENGTH_LONG).show();
    }
}

PrefUtilities.with(this).setUserLogin(false);