Android facebook登录回调多次触发

我的应用程序正在使用共享按钮在用户时间线上共享故事。我正在做的是，用户点击共享按钮，若用户会话不存在，应用程序将强制用户登录Facebook。 当用户这样做时，故事需要直接发布。这是我的密码

onCreate方法

    isShared = false;
    uiHelper = new UiLifecycleHelper(this, statusCallback);
    uiHelper.onCreate(savedInstanceState);
    Settings.addLoggingBehavior(LoggingBehavior.INCLUDE_ACCESS_TOKENS);
    Session session = Session.getActiveSession();
    if (session == null) {

        if (savedInstanceState != null) {
            session = Session.restoreSession(this, null, statusCallback,
                    savedInstanceState);
        }
        if (session == null) {
            session = new Session(this);
        }
        Session.setActiveSession(session);
        if (session.getState().equals(SessionState.CREATED_TOKEN_LOADED)) {
            session.openForRead(new Session.OpenRequest(this)
                    .setCallback(statusCallback));
        }
    }       

    if (savedInstanceState != null) {
        pendingPublishReauthorization = savedInstanceState.getBoolean(
                PENDING_PUBLISH_KEY, false);
    }

    shareBtn.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View arg0) {
            doPostStory();                              
        }
    });

剩下的代码是-

    private void doPostStory() {
    Session session = Session.getActiveSession();
    if (!session.isOpened() && !session.isClosed()) {
        session.openForRead(new Session.OpenRequest(this)
                .setCallback(statusCallback));
    } else {
        isShared = true;
        Session.openActiveSession(this, true, statusCallback);
        publishStory();         
    }
}

private class SessionStatusCallback implements Session.StatusCallback {
    @Override
    public void call(Session session, SessionState state,
            Exception exception) {
        if(!isShared){
            updateView();
            isShared = true;
        }
    }
}

private void updateView() {
    Session session = Session.getActiveSession();
    if (session.isOpened()) {
        if(!isShared){
            publishStory();
        }
        Log.i("Session State callback", "Logged in");
    } else {
        Log.i("Session State Callback", "Logged Out");                      
    }
}   

@Override
public void onStart() {
    super.onStart();
    Session.getActiveSession().addCallback(statusCallback);
}

@Override
public void onStop() {
    super.onStop();
    Session.getActiveSession().removeCallback(statusCallback);
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    Session.getActiveSession().onActivityResult(this, requestCode,
            resultCode, data);
    uiHelper.onActivityResult(requestCode, resultCode, data);
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    Session session = Session.getActiveSession();
    Session.saveSession(session, outState);
    outState.putBoolean(PENDING_PUBLISH_KEY, pendingPublishReauthorization);
    uiHelper.onSaveInstanceState(outState);
}

@Override
public void onPause() {
    super.onPause();
    uiHelper.onPause();
}

@Override
public void onResume() {
    super.onResume();
    uiHelper.onResume();
}

publishStory（）代码

private void publishStory（）{
Session=Session.getActiveSession（）；
if（会话！=null）{
//检查发布权限
List permissions=session.getPermissions（）；
如果（！isSubsetOf（权限、权限））{
pendingPublishReauthorization=真；
Session.newpermissions请求newpermissions请求=newsession.newpermissions请求(
这包括许可）；
session.requestNewPublishPermissions（newPermissionsRequest）；
返回；
}
Bundle postParams=新Bundle（）；
postParams.putString（“name”、“Some”）；
putString（“标题”，updateTitle）；
putString（“description”，updateText）；
postParams.putString（“链接”http://somedomain.com");
postParams.putString（“picture”、“someurl”）；
Request.Callback=new Request.Callback（）{
未完成公共无效（响应）{
JSONObject graphResponse=response.getGraphObject（）
.getInnerJSONObject（）；
字符串postId=null；
试一试{
postId=graphResponse.getString（“id”）；
}捕获（JSONException e）{
Log.i（“asd”、“JSON错误”+e.getMessage（））；
}
FacebookRequestError=response.getError（）；
if（错误！=null）{
Toast.makeText（UpdateDetails.this，
error.getErrorMessage（），Toast.LENGTH\u SHORT）
.show（）；
}否则{
Toast.makeText（UpdateDetails.this，posted，
Toast.LENGTH_LONG）.show（）；
}
}
};
请求=新请求（会话“me/feed”、后参数、，
HttpMethod.POST，回调）；
RequestAsyncTask任务=新的RequestAsyncTask（请求）；
task.execute（）；
}否则{
Log.i（“会话状态”、“结束”）；
}
}

代码不会在用户时间线上发布故事。但它发布了多次。这意味着，

statusCallback

被多次解雇。我尝试设置标志来检查故事帖子的状态。但它仍然发布了好几次

你知道这个代码有什么问题吗？非常感谢您的帮助

---

我不需要单独的登录按钮。我想要的是，用户点击共享按钮，如果登录它需要发布故事，否则登录用户，然后直接发布故事。

删除所有

publishStory（）

调用。在回调中执行以下操作：

public void call(Session session, SessionState state,
        Exception exception) {
    if(session != null && session.isOpened() && isShared){
       publishStory();
    }
}

在

UpdateDetails

类中，将

isShared

声明为

boolean isShared=false
当用户点击“共享”按钮时，使其成为现实，如：

shareBtn.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View arg0) {
        isShared = true;
        doPostStory();                              
    }
});

在您的
publishStory
s
onComplete
make
ishared
false中。比如：

public void onCompleted(Response response) {
    isShared = false;
    ...................
    ...................
}

希望这会有所帮助。
创建Facebook会话对象

然后在onCreate方法中应用它

 Session.openActiveSession(this, true, new Session.StatusCallback() {

        // callback when session changes state
        @Override
        public void call(Session session, SessionState state,
                Exception exception) {
            if (session.isOpened()) {

                // make request to the /me API
                Request.newMeRequest(session,
                        new Request.GraphUserCallback() {

                            // callback after Graph API response with user
                            // object
                            @Override
                            public void onCompleted(GraphUser user,
                                    Response response) {
                                FacebookLoginActivity.this.progressDialog = ProgressDialog
                                        .show(YourActivity.this,
                                                "",
                                                "",
                                                true);
                                if (user != null) {

                                   Intent passIntent = new Intent(YourActivity.this,Second.class)
                                   startActivity(passIntent)
                                }
                            }
                        }).executeAsync();

            }
        }
    });

发布您的
publishStory（）
@Shoshi添加了
publishStory（）
在您点击共享按钮之前您的故事是否正在发布？否。。只有在我点击按钮后，它才会发布很多次。你能告诉我，它发布了多少次吗？这是正确的。会话可以过渡到许多状态，所有这些状态都将导致调用回调。您应该始终选中isOpened（）。
 Session.openActiveSession(this, true, new Session.StatusCallback() {

        // callback when session changes state
        @Override
        public void call(Session session, SessionState state,
                Exception exception) {
            if (session.isOpened()) {

                // make request to the /me API
                Request.newMeRequest(session,
                        new Request.GraphUserCallback() {

                            // callback after Graph API response with user
                            // object
                            @Override
                            public void onCompleted(GraphUser user,
                                    Response response) {
                                FacebookLoginActivity.this.progressDialog = ProgressDialog
                                        .show(YourActivity.this,
                                                "",
                                                "",
                                                true);
                                if (user != null) {

                                   Intent passIntent = new Intent(YourActivity.this,Second.class)
                                   startActivity(passIntent)
                                }
                            }
                        }).executeAsync();

            }
        }
    });