我有一个按钮，点击登录facebook的，但有时这code不能正常工作。抛出异常：产生的原因：

  com.facebook.FacebookException：无法通过一个发布或管理权限（电子邮件），以读取授权请求
 

这是我的活动的code：

 公共类FacebookLoginActivity延伸活动{

    私人最终静态字符串变量=FB;

    私有静态最后的名单，其中，字符串＆GT; PERMISSIONS = Arrays.asList（电子邮件，user_likes，user_status）;

    私人Session.StatusCallback statusCallback =新SessionStatusCallback（）;

    私人GraphUser用户= NULL;

    私人束束;

    私人意图myIntent;

    私人届会议;

    私有静态FacebookLoginActivity实例=新FacebookLoginActivity（）;
    @覆盖
    公共无效的onCreate（包savedInstanceState）{
        super.onCreate（savedInstanceState）;
        如果（丛== NULL）{
            捆绑=新包（）;
        }
        （在FB onCreate方法标签）Log.v;
        myIntent = this.getIntent（）;
        requestWindowFeature（Window.FEATURE_NO_TITLE）;
        getWindow（）setFlags（WindowManager.LayoutParams.FLAG_FULLSCREEN，WindowManager.LayoutParams.FLAG_FULLSCREEN）。
        串动= ClientUtil.getElementValue（行动）;

        Settings.addLoggingBehavior（LoggingBehavior.INCLUDE_ACCESS_TOKENS）;
        会议= openActiveSession（这一点，真，权限）;
        onClickLogin（）;
    }



    公共无效onClickLogin（）{
        Log.v（TAG，点击登录BTN）;
        会议= Session.getActiveSession（）;
        如果（session.isOpened（）及！＆安培;！session.isClosed（））{
            OpenRequest openRequest =新Session.OpenRequest（本）;
            openRequest.setPermissions（权限）;
            openRequest.setCallback（statusCallback）;
            openRequest.setDefaultAudience（SessionDefaultAudience.FRIENDS）;
            openRequest.setLoginBehavior（SessionLoginBehavior.SSO_WITH_FALLBACK）;
            session.openForPublish（openRequest）;
        } 其他 {
            Log.v（TAG，开放活动会话）;
            Session.openActiveSession（这一点，真，statusCallback）;
        }
    }

    @覆盖
    公共无效的OnStart（）{
        super.onStart（）;
        Log.v（TAG，ONSTART方法添加FB回调）;
        。Session.getActiveSession（）的addCallback（statusCallback）;
    }

    @覆盖
    公共无效的onStop（）{
        super.onStop（）;
        Log.v（TAG的onStop方法来删除FB回调）;
        。Session.getActiveSession（）removeCallback（statusCallback）;
    }

    @覆盖
    公共无效onActivityResult（INT申请code，INT结果code，意图数据）{
        super.onActivityResult（要求code，因此code，数据）;
        Log.v（TAG，onActivityResult方法调用FB会议）;
        Session.getActiveSession（）onActivityResult（这一点，要求code，因此code，数据）。
    }

    @覆盖
    保护无效的onSaveInstanceState（包outState）{
        super.onSaveInstanceState（outState）;
        会话会话= Session.getActiveSession（）;
        Session.saveSession（会话，outState）;
    }

    私有静态会话openActiveSession（活动活动，布尔allowLoginUI，列表和LT;字符串＆gt;权限）{
        OpenRequest openRequest =新OpenRequest（活动）.setPermissions（权限）;
        会话会话=新Session.Builder（活动）.build（）;
        如果（SessionState.CREATED_TOKEN_LOADED.equals（session.getState（））|| allowLoginUI）{
            Session.setActiveSession（会议）;
            session.openForPublish（openRequest）;
            返回会议;
        }
        返回null;
    }

    私有类SessionStatusCallback实现Session.StatusCallback {

        @覆盖
        公共无效呼叫（会话的会话，SessionState会状态，例外的例外）{
            Log.v（TAG，在StatusCallback调用方法的例外是：+除外）;
            Log.v（TAG，会话状态是：+ session.isOpened（））;
            如果（用户！= NULL）{
                Log.v（TAG，FB用户存在待办事项登录YYY）;
                登录（）;
                完（）;
                Log.v（TAG，完成FB活动）;
                返回;
            }
            如果（session.isOpened（））{
                Log.v（TAG，会话被打开调用FB请求）;
                Request.executeMeRequestAsync（会话，新Request.GraphUserCallback（）{

                    @覆盖
                    公共无效onCompleted（GraphUser我，响应响应）{
                        （在GraphUserCallback onCompleted法的标签，）Log.v;
                        Log.v（TAG，GraphUser都有价值：+（用户= NULL）！）;
                        如果（我！= NULL）{
                            USER =我。
                            登录（）;
                        }
                        完（）;
                        Log.v（TAG，完成FB活动）;
                    }
                }）;
            }其他{
                Log.v（TAG，会议不开）;
                如果（例外= NULL和放大器;！＆安培; exception.toString（）包含（取消））{
                    Log.v（TAG，CANCLE登录）;
                    bundle.putInt（code，响应code.CANCLE）;
                    myIntent.putExtras（包）;
                    的setResult（Activity.RESULT_OK，myIntent）;
                    完（）;
                }
            }
        }
    }
}
 

解决方案

您不能调用openForPublish，除非你的应用程序已被授予基本权限第一。

分离出您的权限列表分为PERMISSIONS_READ和PERMISSIONS_PUBLISH，并把电子邮件到发布方。然后调用openForRead，然后requestNewPublishPermissions当你的会议是开放的。

I have a button click to login facebook,but sometimes this code can't work. throw exception:Caused by:

com.facebook.FacebookException: Cannot pass a publish or manage permission (email) to a request for read authorization

This is my activity's code :

public class FacebookLoginActivity extends Activity {

    private final static String TAG="FB";

    private static final List<String> PERMISSIONS=Arrays.asList("email", "user_likes", "user_status");

    private Session.StatusCallback statusCallback=new SessionStatusCallback();

    private GraphUser user = null;

    private Bundle bundle;

    private Intent myIntent;

    private Session session;

    private static FacebookLoginActivity instance=new FacebookLoginActivity();
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if(bundle==null){
            bundle=new Bundle();
        }
        Log.v(TAG, "in FB onCreate method");
        myIntent = this.getIntent();
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        String action = ClientUtil.getElementValue("action");

        Settings.addLoggingBehavior(LoggingBehavior.INCLUDE_ACCESS_TOKENS);
        session=openActiveSession(this, true, PERMISSIONS);
        onClickLogin();
    }



    public void onClickLogin() {
        Log.v(TAG, "click login btn");
        session = Session.getActiveSession();
        if (!session.isOpened() && !session.isClosed()) {
            OpenRequest openRequest=new Session.OpenRequest(this);
            openRequest.setPermissions(PERMISSIONS);
            openRequest.setCallback(statusCallback);
            openRequest.setDefaultAudience(SessionDefaultAudience.FRIENDS);
            openRequest.setLoginBehavior(SessionLoginBehavior.SSO_WITH_FALLBACK);
            session.openForPublish(openRequest);
        } else {
            Log.v(TAG, "open active session");
            Session.openActiveSession(this, true, statusCallback);
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.v(TAG, "onStart method to add  fb Callback");
        Session.getActiveSession().addCallback(statusCallback);
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.v(TAG, "onStop method to remove fb callback");
        Session.getActiveSession().removeCallback(statusCallback);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        Log.v(TAG, "onActivityResult method to call Fb Session");
        Session.getActiveSession().onActivityResult(this, requestCode, resultCode, data);
    }

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

    private static Session openActiveSession(Activity activity, boolean allowLoginUI, List<String> permissions) {
        OpenRequest openRequest = new OpenRequest(activity).setPermissions(permissions);
        Session session = new Session.Builder(activity).build();
        if (SessionState.CREATED_TOKEN_LOADED.equals(session.getState()) || allowLoginUI) {
            Session.setActiveSession(session);
            session.openForPublish(openRequest);
            return session;
        }
        return null;
    }

    private class SessionStatusCallback implements Session.StatusCallback {

        @Override
        public void call(Session session, SessionState state, Exception exception) {
            Log.v(TAG, "in StatusCallback call method exception is:"+ exception);
            Log.v(TAG, "session state is:"+session.isOpened());
            if(user != null) {
                Log.v(TAG, "fb user is exist todo login yyy");
                login();
                finish();
                Log.v(TAG, "finish fb activity");
                return;
            }
            if(session.isOpened()) {
                Log.v(TAG, "session is opened to call FB Request");
                Request.executeMeRequestAsync(session, new Request.GraphUserCallback() {

                    @Override
                    public void onCompleted(GraphUser me, Response response) {
                        Log.v(TAG, "in GraphUserCallback onCompleted method");
                        Log.v(TAG, "GraphUser has value:"+(user!=null));
                        if(me != null) {
                            user=me;
                            login();
                        }
                        finish();
                        Log.v(TAG, "finish fb activity");
                    }
                });
            }else{
                Log.v(TAG, "session is not open");
                if(exception !=null && exception.toString().contains("Canceled")){
                    Log.v(TAG, "cancle login");
                    bundle.putInt("code", RespondCode.CANCLE);
                    myIntent.putExtras(bundle);
                    setResult(Activity.RESULT_OK, myIntent);
                    finish();
                }
            }
        }
    }       
}

You can't call openForPublish unless your app has already been granted basic permissions first.

Separate out your PERMISSIONS list into PERMISSIONS_READ and PERMISSIONS_PUBLISH, and put "email" into the PUBLISH side. Then call openForRead, and then requestNewPublishPermissions when your session is open.