Java 如果已创建用户，请更正代码位置以检查Firebase？

我已经创建了一个方法，在用户登录后获取他们的facebook数据，并在我的firebase数据库中为他们创建一个“用户”。此方法addUser（）还为所述用户创建和设置变量。但是我必须将该方法保留在login中，这样它就创建了我的变量，然后对该方法进行注释以备将来测试，否则它将重置所有值。 那么，我在哪里可以添加“addUser（）”来第一次创建所述用户，并确保它不再调用它，只要该用户已经存在

main活动（启动和登录）

public类MainActivity扩展了AppCompatActivity{
CallbackManager CallbackManager；
共享对话框共享对话框；
登录按钮登录；
档案图片查看档案；
对话框详细信息\u对话框；
文本查看详细信息；
JSONObject响应；
/*用于跟踪用户从Facebook登录/注销*/
私有AccessTokenTracker mFacebookAccessTokenTracker；
/*对Firebase的引用*/
私人消防基地mFirebaseRef；
/*对Firebase的引用*/
私有Firebase userRef；
/*来自已验证用户的数据*/
公共静态AuthData-mAuthData；
/*Firebase会话更改的侦听器*/
私有Firebase.AuthStateListener mAuthStateListener；
公共静态字符串uName=null；
公共静态字符串uEmail=null；
公共静态字符串uUrl=null；
公共静态int mTokens=50；
公共静态字符串uID=null；
公共静态int getLiveTokens（）{
返回liveTokens；
}
公共静态void setLiveTokens（int-liveTokens）{
MainActivity.liveTokens=liveTokens；
}
公共静态int-liveTokens=0；
公共静态int getLiveSpins（）{
返回liveSpins；
}
公共静态void setLiveSpins（int-liveSpins）{
MainActivity.liveSpins=liveSpins；
}
公共静态int-liveSpins=0；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
mFirebaseRef=新Firebase（“https://.firebaseio.com/");
callbackManager=callbackManager.Factory.create（）；
login=（LoginButton）findViewById（R.id.login_按钮）；
profile=（ProfilePictureView）findViewById（R.id.picture）；
shareDialog=新建shareDialog（此）；
login.setReadPermissions（“public_profile电子邮件”）；
详细信息\u对话框=新建对话框（此对话框）；
详细信息\u对话框.setContentView（R.layout.dialog\u详细信息）；
details_dialog.setTitle（“详细信息”）；
details_txt=（TextView）details_dialog.findviewbyd（R.id.details）；
getLoginDetails（登录）；
mFacebookAccessTokenTracker=新的AccessTokenTracker（）{
@凌驾
受保护的onCurrentAccessTokenChanged无效（AccessToken oldAccessToken、AccessToken currentAccessToken）{
//Log.i（标记“Facebook.AccessTokenTracker.OnCurrentAccessTokenChanged”）；
//Toast.makeText（getApplicationContext（），“FBAccessTokenChange”，Toast.LENGTH_LONG.show（）；
MainActivity.this.onFacebookAccessTokenChange（currentAccessToken）；
}
};
if（AccessToken.getCurrentAccessToken（）！=null）{
请求数据（）；
getLoginDetails（登录）；
getUserInfo（）；
Toast.makeText（getApplicationContext（），“已登录”，Toast.LENGTH_LONG.show（）；
}
login.setOnClickListener（新视图.OnClickListener（）{
@凌驾
公共void onClick（视图）{
if（AccessToken.getCurrentAccessToken（）！=null）{
profile.setProfileId（空）；
}
}
});
mAuthStateListener=new Firebase.AuthStateListener（）{
@凌驾
AuthStateChanged上的公共无效（AuthData AuthData）{
//mAuthProgressDialog.hide（）；
setAuthenticatedUser（authData）；
}
};
/*检查用户是否已经通过Firebase的身份验证。如果是这种情况，我们可以设置身份验证
*用户和隐藏任何登录按钮*/
mFirebaseRef.addAuthStateListener（mAuthStateListener）；
}
public void addUser（）{
this.uID=mAuthData.getUid（）；
Toast.makeText（getApplicationContext（），“设置用户帐户”，Toast.LENGTH_LONG.show（）；
Firebase rootRef=新的Firebase（“https://.firebaseio.com/users/");
Firebase userRef=rootRef.child（mAuthData.getUid（）+“/”）；
userRef.child（“name”）.setValue（mAuthData.getProviderData（）.get（“displayName”）；
userRef.child（“provider”）.setValue（mAuthData.getProvider（））；
userRef.child（“email”）.setValue（mAuthData.getProviderData（）.get（“email”））；
userRef.child（“令牌”）.setValue（“100”）；
userRef.child（“旋转”）.setValue（“100”）；
userRef.child（“totalspins”）.setValue（“0”）；
userRef.child（“topwin”）.setValue（“0”）；
}
受保护的无效getLoginDetails（登录按钮登录）{
registerCallback（callbackManager，newfacebookcallback（）{
@凌驾
成功时公共无效（登录结果登录结果）{
getUserInfo（）；
}
@凌驾
公开作废{
}
@凌驾
public void onError（facebook异常）{
}
});
}
//登录结果登录结果
受保护的void getUserInfo（）{
//LoginResult login_result.getAccessToken（）
GraphRequest data_request=GraphRequest.NewMereRequest（AccessToken.getCurrentAccessToken（），new GraphRequest.GraphJSONObject回调（）{
@凌驾
未完成公共void（JSONObject json_对象，GraphResponse响应）{
意向意向=新意向（MainActivity.this、HomeActivity.class）；
putExtra（“jsondata”，json
public class MainActivity extends AppCompatActivity {
    CallbackManager callbackManager;
    ShareDialog shareDialog;
    LoginButton login;
    ProfilePictureView profile;
    Dialog details_dialog;
    TextView details_txt;
    JSONObject response;

    /* Used to track user logging in/out off Facebook */
    private AccessTokenTracker mFacebookAccessTokenTracker;

    /* A reference to the Firebase */
    private Firebase mFirebaseRef;

    /* A reference to the Firebase */
    private Firebase userRef;

    /* Data from the authenticated user */
    public static AuthData mAuthData;

    /* Listener for Firebase session changes */
    private Firebase.AuthStateListener mAuthStateListener;

    public static String uName = null;

    public static String uEmail = null;

    public static String uUrl = null;

    public static int mTokens = 50;

    public static String uID = null;

    public static int getLiveTokens() {
        return liveTokens;
    }

    public static void setLiveTokens(int liveTokens) {
        MainActivity.liveTokens = liveTokens;
    }

    public static int liveTokens = 0;

    public static int getLiveSpins() {
        return liveSpins;
    }

    public static void setLiveSpins(int liveSpins) {
        MainActivity.liveSpins = liveSpins;
    }

    public static int liveSpins = 0;

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

        setContentView(R.layout.activity_main);

        mFirebaseRef = new Firebase("https://<url>.firebaseio.com/");

        callbackManager = CallbackManager.Factory.create();
        login = (LoginButton) findViewById(R.id.login_button);

        profile = (ProfilePictureView) findViewById(R.id.picture);
        shareDialog = new ShareDialog(this);
        login.setReadPermissions("public_profile email");

        details_dialog = new Dialog(this);
        details_dialog.setContentView(R.layout.dialog_details);
        details_dialog.setTitle("Details");
        details_txt = (TextView) details_dialog.findViewById(R.id.details);

        getLoginDetails(login);

        mFacebookAccessTokenTracker = new AccessTokenTracker() {
            @Override
            protected void onCurrentAccessTokenChanged(AccessToken oldAccessToken, AccessToken currentAccessToken) {
                //Log.i(Tag, "Facebook.AccessTokenTracker.OnCurrentAccessTokenChanged");
              //  Toast.makeText(getApplicationContext(), "FBAccessTokenChange", Toast.LENGTH_LONG).show();

                MainActivity.this.onFacebookAccessTokenChange(currentAccessToken);
            }
        };

        if (AccessToken.getCurrentAccessToken() != null) {
            RequestData();
            getLoginDetails(login);
            getUserInfo();

            Toast.makeText(getApplicationContext(), "Already Logged In", Toast.LENGTH_LONG).show();
        }

        login.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                if (AccessToken.getCurrentAccessToken() != null) {
                    profile.setProfileId(null);
                }
            }
        });

        mAuthStateListener = new Firebase.AuthStateListener() {
            @Override
            public void onAuthStateChanged(AuthData authData) {
               // mAuthProgressDialog.hide();
                setAuthenticatedUser(authData);
            }
        };
        /* Check if the user is authenticated with Firebase already. If this is the case we can set the authenticated
         * user and hide hide any login buttons */
        mFirebaseRef.addAuthStateListener(mAuthStateListener);
    }

    public void addUser() {

        this.uID = mAuthData.getUid();

        Toast.makeText(getApplicationContext(), "Setting Up User Account", Toast.LENGTH_LONG).show();

        Firebase rootRef = new Firebase("https://<url>.firebaseio.com/users/");
        Firebase userRef = rootRef.child(mAuthData.getUid() + "/");
        userRef.child("name").setValue(mAuthData.getProviderData().get("displayName"));
        userRef.child("provider").setValue(mAuthData.getProvider());
        userRef.child("email").setValue(mAuthData.getProviderData().get("email"));
        userRef.child("tokens").setValue("100");
        userRef.child("spins").setValue("100");
        userRef.child("totalspins").setValue("0");
        userRef.child("topwin").setValue("0");
    }

    protected void getLoginDetails(LoginButton login){

        login.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {

            @Override
            public void onSuccess(LoginResult login_Result) {
                getUserInfo();
            }

            @Override
            public void onCancel() {
            }

            @Override
            public void onError(FacebookException exception) {
            }
        });
    }

    // LoginResult login_result
    protected void getUserInfo() {

        // LoginResult login_result.getAccessToken()

        GraphRequest data_request = GraphRequest.newMeRequest(AccessToken.getCurrentAccessToken(), new GraphRequest.GraphJSONObjectCallback() {

            @Override
            public void onCompleted(JSONObject json_object, GraphResponse response) {

                Intent intent = new Intent(MainActivity.this, HomeActivity.class);
                intent.putExtra("jsondata", json_object.toString());
                intent.putExtra("Uid", uID);
                startActivity(intent);
            }
        });

        Bundle permission_param = new Bundle();
        permission_param.putString("fields", "id,name,email,picture.width(120).height(120)");
        data_request.setParameters(permission_param);
        data_request.executeAsync();
    }

    public void RequestData() {
        GraphRequest request = GraphRequest.newMeRequest(AccessToken.getCurrentAccessToken(), new GraphRequest.GraphJSONObjectCallback() {
            @Override
            public void onCompleted(JSONObject object, GraphResponse response) {

                JSONObject json = response.getJSONObject();
                try {
                    if (json != null) {
                        String text = "<b>Name :</b> " + json.getString("name") + "<br><br><b>Email :</b> " + json.getString("email") + "<br><br><b>Profile link :</b> " + json.getString("link");
                        details_txt.setText(Html.fromHtml(text));
                        profile.setProfileId(json.getString("id"));
                        uName = json.getString("name");
                        uEmail = json.getString("email");

                        uUrl = json.getString("id");
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        });

        Bundle parameters = new Bundle();
        parameters.putString("fields", "id,name,link,email,picture");
        request.setParameters(parameters);
        request.executeAsync();
    }

    /**
     * This method will attempt to authenticate a user to firebase given an oauth_token (and other
     * necessary parameters depending on the provider)
     */
    private void authWithFirebase(final String provider, Map<String, String> options) {
        if (options.containsKey("error")) {
           showErrorDialog(options.get("error"));
        } else {
            //mAuthProgressDialog.show();

                // if the provider is not twitter, we just need to pass in the oauth_token
                mFirebaseRef.authWithOAuthToken(provider, options.get("oauth_token"), new AuthResultHandler(provider));
            }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        callbackManager.onActivityResult(requestCode, resultCode, data);
    }

    private void setAuthenticatedUser(AuthData authData) {
        if (authData != null) {

            /* show a provider specific status text */
            String name = null;
            if (authData.getProvider().equals("facebook")) {
                name = (String) authData.getProviderData().get("displayName");
            } else if (authData.getProvider().equals("anonymous")
                    || authData.getProvider().equals("password")) {
                name = authData.getUid();
            } else {
                Toast.makeText(getApplicationContext(), "invalid provider", Toast.LENGTH_LONG).show();
            }
            if (name != null) {

                //success
              //  Toast.makeText(getApplicationContext(), "Log " + name + " (" + authData.getProvider() + ")", Toast.LENGTH_LONG).show();

            }

        } else {

        }

        // Firebase Authenticated

        this.mAuthData = authData;

        MainActivity.uID = mAuthData.getUid();

       //addUser();
        /* invalidate options menu to hide/show the logout button */
        supportInvalidateOptionsMenu();
    }


    /**
     * Show errors to users
     */
    private void showErrorDialog(String message) {
        new AlertDialog.Builder(this)
                .setTitle("Error")
                .setMessage(message)
                .setPositiveButton(android.R.string.ok, null)
                .setIcon(android.R.drawable.ic_dialog_alert)
                .show();
    }

    private class AuthResultHandler implements Firebase.AuthResultHandler {

        private final String provider;

        public AuthResultHandler(String provider) {
            this.provider = provider;
        }

        @Override
        public void onAuthenticated(AuthData authData) {
          //  mAuthProgressDialog.hide();
         //   Toast.makeText(getApplicationContext(), "Auth Success", Toast.LENGTH_LONG).show();
           // Toast.makeText(getApplicationContext(), authData.getUid(), Toast.LENGTH_LONG).show();

           // createUser();

            setAuthenticatedUser(authData);

           String mEmail = authData.getUid();

           // uID = authData.getUid();

            String mProvide = mAuthData.getProvider();

        }

        @Override
        public void onAuthenticationError(FirebaseError firebaseError) {
            //mAuthProgressDialog.hide();
            showErrorDialog(firebaseError.toString());
        }
    }

    public void createUser(){

        Firebase rootRef = new Firebase("https://<url>.firebaseio.com/");
       Firebase userRef = rootRef.child("users").child(mAuthData.getUid());

        userRef.child("provider").setValue(mAuthData.getProvider());
        userRef.child("provider").setValue(mAuthData.getProviderData().get("displayName)"));


        rootRef.createUser(mAuthData.getProviderData().get("email").toString(), mAuthData.getProviderData().get("id").toString(), new Firebase.ValueResultHandler<Map<String, Object>>() {

            @Override
            public void onSuccess(Map<String, Object> result){
                Toast.makeText(getApplicationContext(), "Yes-UID=" + result.get("Uid") , Toast.LENGTH_LONG).show();

            }

            @Override
            public void onError(FirebaseError firebaseError){
                Toast.makeText(getApplicationContext(), "Not Created", Toast.LENGTH_LONG).show();


            }


        });

    }


    private void logout() {
        if (this.mAuthData != null) {
            /* logout of Firebase */
            mFirebaseRef.unauth();
            /* Logout of any of the Frameworks. This step is optional, but ensures the user is not logged into
             * Facebook/Google+ after logging out of Firebase. */
            if (this.mAuthData.getProvider().equals("facebook")) {
                /* Logout from Facebook */
                LoginManager.getInstance().logOut();
            }
            /* Update authenticated user and show login buttons */
            setAuthenticatedUser(null);
        }
    }


    @Override
    protected void onResume() {

        super.onResume();
        AppEventsLogger.activateApp(this);

    }

    @Override
    protected void onPause() {

        super.onPause();
        AppEventsLogger.deactivateApp(this);

    }


    /* ************************************
     *             FACEBOOK               *
     **************************************
     */
    private void onFacebookAccessTokenChange(AccessToken token) {
        if (token != null) {
            //mAuthProgressDialog.show();
            mFirebaseRef.authWithOAuthToken("facebook", token.getToken(), new AuthResultHandler("facebook"));
        } else {
            // Logged out of Facebook and currently authenticated with Firebase using Facebook, so do a logout
            if (this.mAuthData != null && this.mAuthData.getProvider().equals("facebook")) {
                mFirebaseRef.unauth();
                setAuthenticatedUser(null);
            }
        }
    }


    public static int getmTokens() {

       return getLiveTokens();

    }

    public static void setmTokens(int mTokens) {
        MainActivity.mTokens = mTokens;
    }

    public static void takemTokens(int mTokens) {
        MainActivity.mTokens -= mTokens;
    }

    public static void givemTokens(final int ttokens) {
        //MainActivity.mTokens += tokens;

        // TODO
       // if (ttokens > MainActivity.getmTopWin()){
        //    MainActivity.setmTopWin(ttokens);
        //}

        Firebase ref = new Firebase("https://<url>.firebaseio.com/users/" +  MainActivity.uID + "/");
        final Firebase tokensRef = ref.child("tokens");
        tokensRef.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                int iii = new Integer(dataSnapshot.getValue().toString());

                iii += ttokens;

                tokensRef.setValue(iii);

                setLiveTokens(iii);

                checkmTopWin(ttokens);

            }

            @Override
            public void onCancelled(FirebaseError firebaseError) {
            }

        });
        //tokensRef.removeEventListener(MainActivity);

    }


    public static int mSpins = 30;

    public static int getmSpins() {
        return getLiveSpins();
    }

    public static void setmSpins(int mspins) {
        MainActivity.mSpins = mspins;
    }

    public static void takemSpins(final int mspins) {

        Firebase ref = new Firebase("https://<url>.firebaseio.com/users/" +  MainActivity.uID + "/");
        final Firebase tokensRef = ref.child("spins");
        tokensRef.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                int i = Integer.valueOf(dataSnapshot.getValue().toString());

                i -= mspins;

                tokensRef.setValue(i);
                setLiveSpins(i);

            }
            @Override
            public void onCancelled(FirebaseError firebaseError) {}
        });

    }

    public static void givemSpins(final int mspins){

        Firebase ref = new Firebase("https://<url>.firebaseio.com/users/" +  MainActivity.uID + "/");
        final Firebase tokensRef = ref.child("spins");
        tokensRef.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                int i = Integer.valueOf(dataSnapshot.getValue().toString());

                i += mspins;

                tokensRef.setValue(i);
            }
            @Override
            public void onCancelled(FirebaseError firebaseError) {}
        });


    }

    public static int slotVari = 0;

    public static int getSlotVari() {
        return slotVari;
    }

    public static void setSlotVari(int slotVari) {
        MainActivity.slotVari = slotVari;
    }


    public static int mTotalSpins;

    public static int getmTotalSpins() {
        return mTotalSpins;
    }

    public static void setmTotalSpins(int mTotalSpins) {
        MainActivity.mTotalSpins = mTotalSpins;
    }

    public static void incmTotalSpins(){

        Firebase ref = new Firebase("https://<url>.firebaseio.com/users/" +  MainActivity.uID + "/");
        final Firebase tokensRef = ref.child("totalspins");
        tokensRef.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                int i = Integer.valueOf(dataSnapshot.getValue().toString());

                i++;

                tokensRef.setValue(i);
            }
            @Override
            public void onCancelled(FirebaseError firebaseError) {}
        });

        MainActivity.mTotalSpins++;
    }


    public static int mTopWin;

    public static int getmTopWin() {
        return mTopWin;
    }

    public static void setmTopWin(int mTopWin) {

        Firebase ref = new Firebase("https://<url>.firebaseio.com/users/" +  MainActivity.uID + "/");
        Firebase tokensRef = ref.child("topwin");

        tokensRef.setValue(mTopWin);

        MainActivity.mTopWin = mTopWin;
    }

    public static void checkmTopWin(final int mTokensWon) {

        Firebase ref = new Firebase("https://<url>.firebaseio.com/users/" +  MainActivity.uID + "/");
        final Firebase tokensRef = ref.child("topwin");
        tokensRef.addListenerForSingleValueEvent(new ValueEventListener() {
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {
                int i = Integer.valueOf(dataSnapshot.getValue().toString());

                if (i < mTokensWon){

                    tokensRef.setValue(mTokensWon);

                }

            }
            @Override
            public void onCancelled(FirebaseError firebaseError) {}
        });
    }
}

SharedPreferences pref = getSharedPreferences(Constants.ApplicationTag, Activity.MODE_PRIVATE);

if (!pref.contains(Constants.FIRST_LAUNCH)) {
    addUser();
    pref.edit().putBoolean(Constants.FIRST_LAUNCH, true).commit();
}

Firebase rootRef = new Firebase("https://<url>.firebaseio.com/users/");
Firebase userRef = rootRef.child(mAuthData.getUid() + "/");

userRef.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        if (dataSnapshot.exists()) {

            // User exists. Do nothing

        } else addUser();

    }

    @Override
    public void onCancelled(FirebaseError firebaseError) {}
});