如果我使用Firebase简单用户名&；如何返回用户列表；密码验证

不确定我是否做错了什么，但是使用这个api我可以成功地创建一个用户-根据返回消息，但是我在Forge控制台的任何地方都看不到该用户。您如何知道注册了哪些用户

---

我应该使用返回的用户ID并在Firebase中创建自己的用户对象，还是不需要复制。我确实需要添加一些额外的用户属性，因此可能我无论如何都需要这样做。

在Firebase身份验证（以前称为Firebase SimpleLogin）中使用电子邮件/密码身份验证时，用户的电子邮件和密码组合与Firebase中实际存储的数据分开安全地存储

Firebase中的数据和用户的电子邮件/密码散列组合之间的这一屏障是设计造成的：我们希望使您能够更轻松地（1）开发应用程序，（2）防止任何意外的用户凭据泄漏，以及（3）在如何将用户数据存储在Firebase中方面仍然具有完全的灵活性

---

这意味着我们只存储电子邮件地址/密码哈希组合，而不存储其他内容，因此，您可以决定如何在Firebase中存储实际用户数据。正如您所建议的，您应该获取用户id并将该数据存储在Firebase中的某个位置，例如/users/$id，然后使用Firebase确定对该数据的读/写访问权限。您编写规则时使用的

auth

变量中已经包含了您用户唯一的

id

和

email

。

这里我创建了一个Android程序，按照Rob为firebase初学者（像我一样）所说的做 这个程序首先存储signedUp或signedIn用户的用户名，然后在列表视图中显示它们

signianctivity.java

public class SignInActivity extends BaseActivity implements View.OnClickListener,View.OnKeyListener{

    private DatabaseReference mDatabase;
    public static FirebaseAuth mAuth;
    private static final String TAG = "MainActivity";

    EditText usernameField;
    EditText passwordField;
    TextView changeSignUpModeTextView;
    Button signUpButton;
    ImageView logo;
    RelativeLayout relativeLayout;

    Boolean signUpModeActive;
    static ArrayList<String> userList = new ArrayList<>();

    @Override
    public void onStart() {
        super.onStart();

        // Check auth on Activity start
        if (mAuth.getCurrentUser() != null) {
            onAuthSuccess(mAuth.getCurrentUser());
        }
    }
    @Override
    public boolean onKey(View view, int i, KeyEvent keyEvent) {

        if(i == keyEvent.KEYCODE_ENTER && keyEvent.getAction() == keyEvent.ACTION_DOWN){
            signUpOrLogIn(view);
        }
         return false;
    }

    @Override
    public void onClick(View view) {

        if(view.getId() == R.id.changeSignUpMode){

            if (signUpModeActive == true){

                signUpModeActive = false;
                changeSignUpModeTextView.setText("Sign Up");
                signUpButton.setText("Log In");

            }else{

                signUpModeActive = true;
                changeSignUpModeTextView.setText("Log In");
                signUpButton.setText("Sign Up");
            }

        }else if(view.getId() == R.id.logo || view.getId() == R.id.relativeLayout){

            InputMethodManager inm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
            inm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);

        }

    }


    public void signUpOrLogIn(View view) {

        showProgressDialog();
        String email = usernameField.getText().toString().trim();
        String password = passwordField.getText().toString().trim();

        if (signUpModeActive == true) {
            mAuth.createUserWithEmailAndPassword(email,password)
                    .addOnCompleteListener(MainActivity.this, new OnCompleteListener<AuthResult>() {
                        @Override
                        public void onComplete(@NonNull Task<AuthResult> task) {
                            hideProgressDialog();
                            Toast.makeText(MainActivity.this, "createUserWithEmail:onComplete:" + task.isSuccessful(), Toast.LENGTH_SHORT).show();
                            // 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()) {
                                Toast.makeText(MainActivity.this, "Authentication failed." + task.getException().toString().substring(task.getException().toString().indexOf(" ")),
                                        Toast.LENGTH_SHORT).show();
                                Log.i("Error", task.getException().toString());
                            } else {
                                onAuthSuccess(task.getResult().getUser());
                                showUserList();
                            }
                        }
                    });
        } else {
            mAuth.signInWithEmailAndPassword(email,password)
                    .addOnCompleteListener(MainActivity.this, new OnCompleteListener<AuthResult>() {
                        @Override
                        public void onComplete(@NonNull Task<AuthResult> task) {
                            hideProgressDialog();
                            // 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()) {
                                // there was an error

                                Toast.makeText(MainActivity.this, task.getException().toString(),
                                        Toast.LENGTH_LONG).show();
                            } else

                            {
                                onAuthSuccess(task.getResult().getUser());
                                showUserList();
                            }
                        }
                    });
        }
    }

    public void showUserList(){
        startActivity(new Intent(getApplicationContext(), UserList.class));
        finish();
    }
    private void onAuthSuccess(FirebaseUser user) {
        String username = usernameFromEmail(user.getEmail());

        // Write new user
        writeNewUser(user.getUid(), username, user.getEmail());

        // Go to MainActivity

    }
    private String usernameFromEmail(String email) {
        if (email.contains("@")) {
            return email.split("@")[0];
        } else {
            return email;
        }
    }

    private void writeNewUser(String userId, String name, String email) {
        User user = new User(name, email);

        mDatabase.child("users").child(userId).setValue(user);
        ArrayList<String> userNames = new ArrayList<>();
        userNames.add(name);
        mDatabase.child("usernamelist").setValue(userNames);
    }


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

        mAuth = FirebaseAuth.getInstance();
        mDatabase = FirebaseDatabase.getInstance().getReference();


        if(mAuth.getCurrentUser()!=null){
            showUserList();
        }

        usernameField = (EditText) findViewById(R.id.username);
        passwordField = (EditText) findViewById(R.id.password);
        changeSignUpModeTextView = (TextView) findViewById(R.id.changeSignUpMode);
        signUpButton = (Button) findViewById(R.id.signupbutton);
        logo = (ImageView)findViewById(R.id.logo);
        relativeLayout= (RelativeLayout)findViewById(R.id.relativeLayout);

        signUpModeActive = true;

        changeSignUpModeTextView.setOnClickListener(this);

        usernameField.setOnKeyListener(this);
        passwordField.setOnKeyListener(this);

        logo.setOnClickListener(this);
        relativeLayout.setOnClickListener(this);



    }
}

public class UserList extends AppCompatActivity {

    private static final String TAG = "UserList" ;
    private DatabaseReference userlistReference;
    private ValueEventListener mUserListListener;
    ArrayList<String> usernamelist = new ArrayList<>();
    ArrayAdapter arrayAdapter;;

    ListView userListView;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_user_list);
        userlistReference = FirebaseDatabase.getInstance().getReference().child("usernamelist");
        onStart();
        userListView = (ListView) findViewById(R.id.userlistview);


    }

    @Override
    protected void onStart() {
        super.onStart();
        final ValueEventListener userListener = new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                usernamelist = new ArrayList<>((ArrayList) dataSnapshot.getValue());
                usernamelist.remove(usernameOfCurrentUser());
                Log.i(TAG, "onDataChange: "+usernamelist.toString());
                arrayAdapter = new ArrayAdapter(UserList.this,android.R.layout.simple_list_item_1,usernamelist);
                userListView.setAdapter(arrayAdapter);
            }

            @Override
            public void onCancelled(DatabaseError databaseError) {
                Log.w(TAG, "onCancelled: ",databaseError.toException());
                Toast.makeText(UserList.this, "Failed to load User list.",
                        Toast.LENGTH_SHORT).show();
            }
        };
        userlistReference.addValueEventListener(userListener);

        mUserListListener = userListener;
    }
    public String usernameOfCurrentUser()
    {
        String email = MainActivity.mAuth.getCurrentUser().getEmail();
        if (email.contains("@")) {
            return email.split("@")[0];
        } else {
            return email;
        }
    }
    @Override
    public void onStop() {
        super.onStop();

        // Remove post value event listener
        if (mUserListListener != null) {
            userlistReference.removeEventListener(mUserListListener);
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch(item.getItemId()) {
            case R.id.action_logout:
                FirebaseAuth.getInstance().signOut();
                startActivity(new Intent(this, MainActivity.class));
                finish();
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }
}

public class SignInActivity扩展BaseActivity实现View.OnClickListener、View.OnKeyListener{
私有数据库参考数据库；
公共静态FirebaseAuth mAuth；
私有静态最终字符串TAG=“MainActivity”；
EditText用户名字段；
编辑文本密码字段；
TextView更改注册模式TextView；
按钮标志按钮；
ImageView徽标；
相对的相对的；
布尔注册模式激活；
静态ArrayList userList=新ArrayList（）；
@凌驾
public void onStart（）{
super.onStart（）；
//检查活动启动时的身份验证
if（mAuth.getCurrentUser（）！=null）{
onAuthSuccess（mAuth.getCurrentUser（））；
}
}
@凌驾
公共布尔onKey（视图、int i、KeyEvent KeyEvent）{
如果（i==keyEvent.KEYCODE\u输入&&keyEvent.getAction（）==keyEvent.ACTION\u向下）{
注册登录（视图）；
}
返回false；
}
@凌驾
公共void onClick（视图）{
if（view.getId（）==R.id.changeSignUpMode）{
if（signUpModeActive==true）{
signUpModeActive=false；
changeSignUpModeTextView.setText（“注册”）；
signUpButton.setText（“登录”）；
}否则{
signUpModeActive=true；
changeSignUpModeTextView.setText（“登录”）；
signUpButton.setText（“注册”）；
}
}else if（view.getId（）==R.id.logo | | view.getId（）==R.id.relativeLayout）{
InputMethodManager inm=（InputMethodManager）getSystemService（输入方法服务）；
inm.hideSoftInputFromWindow（getCurrentFocus（）.getWindowToken（），0）；
}
}
public void signUpOrLogIn（视图）{
showProgressDialog（）；
字符串email=usernameField.getText（）.toString（）.trim（）；
字符串密码=passwordField.getText（）.toString（）.trim（）；
if（signUpModeActive==true）{
mAuth.createUserWithEmailAndPassword（电子邮件，密码）
.addOnCompleteListener（MainActivity.this，新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
hideProgressDialog（）；
Toast.makeText（MainActivity.this，“createUserWithEmail:onComplete:“+task.issusccessful（），Toast.LENGTH\u SHORT）.show（）；
//如果登录失败，则向用户显示消息。如果登录成功
//将通知身份验证状态侦听器，并使用逻辑来处理
//可以在侦听器中处理已登录用户。
如果（！task.issusccessful（））{
Toast.makeText（MainActivity.this，“身份验证失败”。+task.getException（）.toString（）.substring（task.getException（）.toString（）.indexOf（“”）），
吐司。长度（短）。show（）；
Log.i（“错误”，task.getException（）.toString（））；
}否则{
onAuthSuccess（task.getResult（）.getUser（））；
showUserList（）；
}
}
});
}否则{
mAuth.使用电子邮件和密码登录（电子邮件，密码）
.addOnCompleteListener（MainActivity.this，新的OnCompleteListener（）{
@凌驾
未完成的公共void（@NonNull任务）{
hideProgressDialog（）；
//如果登录失败，则向用户显示消息。如果登录成功
//将通知身份验证状态侦听器，并使用逻辑来处理
//可以在侦听器中处理已登录用户。
如果（！task.issusccessful（））{
//有一个错误
Toast.makeText（MainActivity.this，task.getException（）.toString（），
const serviceAccount = require('path/to/firebase-sdk-json-service-account');

const googleapis = require('googleapis');
const identitytoolkit = googleapis.identitytoolkit('v3');

const authClient = new googleapis.auth.JWT(
    serviceAccount.client_email,
    null,
    serviceAccount.private_key,
    ['https://www.googleapis.com/auth/firebase'],
    null
);

authClient.authorize((err) => {
    if (err) {
        return console.error(err);
    }

    let nextPageToken = undefined;
    let users = [];
    const getAccounts = () => identitytoolkit.relyingparty.downloadAccount({
        auth: authClient,
        resource: {
            targetProjectId: serviceAccount.project_id,
            maxResults: 200,
            nextPageToken: nextPageToken
        }
    }, (e, results) => {
        if (e) {
            return console.error(err);
        }

        users = users.concat(results.users);
        if (results.nextPageToken) {
            nextPageToken = results.nextPageToken;
            return getAccounts();
        } else {
            console.log(users);
        }
    });
    getAccounts();
});

// USERS: return full users list for admin
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
import * as admin from 'firebase-admin'
import * as functions from 'firebase-functions'

export const listUsers = functions.https.onCall((data, context) => {
  // check if user is admin (true "admin" custom claim), return error if not
  const isAdmin = context.auth.token.admin === true
  if (!isAdmin) {
    return { error: `Unauthorized.` }
  }

  return admin
    .auth()
    .listUsers()
    .then((listUsersResult) => {
      // go through users array, and deconstruct user objects down to required fields
      const result = listUsersResult.users.map((user) => {
        const { uid, email, photoURL, displayName, disabled } = user
        return { uid, email, photoURL, displayName, disabled }
      })

      return { result }
    })
    .catch((error) => {
      return { error: 'Error listing users' }
    })
})

FirebaseDatabase.getInstance().getReference().child("my_user")
                        .child(task.getResult().getUser().getUid())
                        .child("username").setValue(autoCompleteTextView1.getText().toString());

function listAllUsers(nextPageToken) {
  // List batch of users, 1000 at a time.
  admin.auth().listUsers(1000, nextPageToken)
    .then(function(listUsersResult) {
      listUsersResult.users.forEach(function(userRecord) {
        console.log('user', userRecord.toJSON());
      });
      if (listUsersResult.pageToken) {
        // List next batch of users.
        listAllUsers(listUsersResult.pageToken);
      }
    })
    .catch(function(error) {
      console.log('Error listing users:', error);
    });
}
// Start listing users from the beginning, 1000 at a time.
listAllUsers();