Каков наилучший способ аутентификации двух типов пользователей (ученик и водитель) в моем приложении для Android с использованием Firebase

Вы должны также использовать базу данных Firebase. Когда ваша регистрация будет успешной, сделайте запись пользователей в базе данных firebase. Добавьте type = "student" или "driver" в каждую запись. Таким образом, вы можете проверить тип входа и изменить его в соответствии с вашими потребностями.

Примерно так во время входа в систему:

/**
     * Login with firebase credentials
     */
    private void loginFirebase() {
        progressDialog();
        FirebaseAuth.getInstance().signInWithEmailAndPassword(emailEt.getText().toString().trim(),
                passwordEt.getText().toString().trim())
                .addOnCompleteListener(LoginActivity.this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        if (!task.isSuccessful()) {
                            dismissDialog();
                            Toast.makeText(LoginActivity.this, "Login failed: "
                                            + UtilMethods.firebaseAuthFailMessage(task),
                                    Toast.LENGTH_SHORT).show();
                        } else {
                            verifyUserType();
                        }
                    }
                });
    }

    /**
     * Verify if user type is customer or business.
     * If type is customer then allow login else Alert the user
     */
    private void verifyUserType() {
        DatabaseReference dbRef = FirebaseDatabase.getInstance().getReference(Constants.FIREBASE_NODE_USER_DETAILS);
        dbRef.child(FirebaseAuth.getInstance().getUid()).addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
                String userType = dataSnapshot.child("type").getValue(String.class);
                if (userType != null && userType.equals("customer")) {
                    //checkIfEmailVerified();
                } else {
                    dismissDialog();
                    Toast.makeText(LoginActivity.this, "You are not authorized to access this application!",
                            Toast.LENGTH_SHORT).show();
                    FirebaseAuth.getInstance().signOut();
                }

            }

            @Override
            public void onCancelled(@NonNull DatabaseError databaseError) {
                dismissDialog();
                Toast.makeText(LoginActivity.this, "" + databaseError.getMessage(), Toast.LENGTH_SHORT).show();
            }
        });

    }

Вот снимок:

Вот процесс регистрации:

private void signUpMethod() {
        progressDialog();
        final String email = emailEt.getText().toString().trim();
        final String password = passwordEt.getText().toString().trim();
        //authenticate user
        firebaseAuth.createUserWithEmailAndPassword(email, password)
                .addOnCompleteListener(SignUpActivity.this, new OnCompleteListener<AuthResult>() {
                    @Override
                    public void onComplete(@NonNull Task<AuthResult> task) {
                        // 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()) {
                            dismissDialog();
                            // there was an error
                            Toast.makeText(SignUpActivity.this, "" + task.getException().getMessage(),
                                    Toast.LENGTH_SHORT).show();
                        } else {
                            addUserDetailsToDatabase(task.getResult().getUser());
                        }
                    }
                });
    }

    private void addUserDetailsToDatabase(FirebaseUser user) {

        DatabaseReference databaseReferenceUsers = firebaseDatabase.getReference("users").child(user.getUid());

        Users usersDetails = new Users();
        usersDetails.setName(storeFullNameEt.getText().toString());
        usersDetails.setMobile(mobileEt.getText().toString());
        usersDetails.setEmail(user.getEmail());
        usersDetails.setAddress(addressEt.getText().toString());
        usersDetails.setCity(cityEt.getText().toString());
        usersDetails.setState(stateEt.getText().toString());
        usersDetails.setPinCode(pinCodeEt.getText().toString());
        usersDetails.setCustomerUId(user.getUid());

        databaseReferenceUsers.setValue(usersDetails).addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                dismissDialog();
                firebaseAuth.signOut();
                finish();
            }
        });

    }

И это ваш модельный класс, создайте поля в соответствии с вашими потребностями:

@IgnoreExtraProperties
public class Users {

    private String name;
    private String mobile;
    private String email;
    private String address;
    private String city;
    private String state;
    private String pinCode;
    private String customerUId;

    public Users() {
        name = "";
        mobile = "";
        email = "";
        address = "";
        city = "";
        state = "";
        pinCode = "";
        customerUId = "";
    }

    @PropertyName("name")
    public String getName() {
        return name;
    }

    @PropertyName("name")
    public void setName(String name) {
        this.name = name;
    }

    @PropertyName("mobile")
    public String getMobile() {
        return mobile;
    }

    @PropertyName("mobile")
    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    @PropertyName("email")
    public String getEmail() {
        return email;
    }

    @PropertyName("email")
    public void setEmail(String email) {
        this.email = email;
    }

    @PropertyName("address")
    public String getAddress() {
        return address;
    }

    @PropertyName("address")
    public void setAddress(String address) {
        this.address = address;
    }

    @PropertyName("city")
    public String getCity() {
        return city;
    }

    @PropertyName("city")
    public void setCity(String city) {
        this.city = city;
    }

    @PropertyName("state")
    public String getState() {
        return state;
    }

    @PropertyName("state")
    public void setState(String state) {
        this.state = state;
    }

    @PropertyName("pinCode")
    public String getPinCode() {
        return pinCode;
    }

    @PropertyName("pinCode")
    public void setPinCode(String pinCode) {
        this.pinCode = pinCode;
    }

    @PropertyName("customerUId")
    public String getCustomerUId() {
        return customerUId;
    }

    @PropertyName("customerUId")
    public void setCustomerUId(String customerUId) {
        this.customerUId = customerUId;
    }
}

Аутентификация Firebase не имеет различия между этими типами пользователей. Все, что он делает, это определяет, является ли пользователь тем, кем он себя считает. Любое различие между типами пользователей должно быть сделано вашим приложением после аутентификации пользователя.

Обычно вы делаете это, сохраняя тип для каждого пользователя в базе данных, такой как База данных в реальном времени или Облачное хранилище пожаров. Там вы связываете каждый UID пользователя с его типом:

user_types:
  user1: "student"
  user2: "driver"
  user3: "student"
  user4: "student"

В качестве альтернативы вы можете сохранить тип пользователя в его профиле пользователя с пользовательской заявкой. Чтобы установить пользовательскую заявку с помощью Admin SDK для Node.js:

admin.auth().setCustomUserClaims(uid, {user_type: "driver"}).then(() => {
  // The new custom claims will propagate to the user ID token the
  // next time a new one is issued.
});

Поскольку это чувствительная операция, ее можно выполнить только через Firebase Admin SDK, которого нет в вашем приложении, но можно использовать только в надежной среде, такой как компьютер для разработки, сервер, которым вы управляете, или облачные функции.,

Также посмотрите эти предыдущие вопросы по теме:

• Как можно обрабатывать отдельный вход для двух типов пользователей в одном приложении Firebase?
• Разные разрешения Firebase Auth
• Как автоматически войти в систему для двух разных типов пользователей для разных действий без повторного входа?
• Как мне различить разные уровни пользователей в firebaseAuth
• Как разделить двух разных пользователей в приложении Firebase Android?

Я не знаю, существует ли официальный или стандартный способ сделать это с помощью Firebase, но если бы это было не так, я бы сохранил тип пользователя в базе данных и затем проверил информацию перед входом в систему. Логика будет следующая:

1. Получить тип пользователя по электронной почте
2. Проверьте, соответствует ли возвращаемый тип типу экрана входа
3. Выполните вход в систему, если тип соответствует, покажите ошибку в противном случае

Надеюсь, это поможет.

У меня такой же подход к одному из моих разработанных приложений, и что я сделал, просто добавив boolean тип к пользователю true если это драйвер, и false если он студент, и вы должны обрабатывать эти учетные данные при регистрации. Так что при входе вы получите тип пользователя!