java - 如果已经创建了用户，则正确的代码位置检查 Firebase？

Question

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

MainActivity(启动和登录)

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) {}
        });
    }
}

Answer 1

您需要设置像 FIRST_LAUNCH 这样的首选项，并在每次用户登录时检查它是否为真。第一次启动应用程序时，FIRST_LAUNCH 首选项不会是成立。因此调用您的 addUser() 函数在您的 FireBase 数据库中创建一个新条目。

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

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

因此您可能会想到，如果用户卸载您的应用程序然后重新安装它，首选项将会消失并且将再次调用 addUser() 函数。没问题，只要子属性的路径相同，您就不会获得新的 Firebase 条目。这些值将被替换为特定路径(如果它存在)，以及用户的当前信息。

现在如果你想检查你的用户是否已经存在于 Firebase 数据库中，你需要像这样添加一个监听器。我附上了一个代码示例以便更好地理解。

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) {}
});