Fatal编程技术网
  • android/
  • Android Facebook发布权限-从服务器发布

Android Facebook发布权限-从服务器发布

android facebook permissions

Android Facebook发布权限-从服务器发布,android,facebook,permissions,Android,Facebook,Permissions,在我的应用程序中，我首先询问用户的基本权限，然后在需要时发布。客户端本身不使用accessToken做任何事情，它只是将其传递给服务器 1） 获得基本权限后，客户端立即将其发送到服务器。 2） 当客户端请求发布权限时，问题开始出现。一旦用户授予发布权限，“我的会话”仍显示旧的基本权限。但若我同时检查fb上的用户设置，则表明该应用程序已授予发布权限。但不知何故，在应用程序中，我没有得到 更新的accessToken 这是我为获得发布许可而做的 private void requestPublish

在我的应用程序中，我首先询问用户的基本权限，然后在需要时发布。客户端本身不使用accessToken做任何事情，它只是将其传递给服务器

1） 获得基本权限后，客户端立即将其发送到服务器。 2） 当客户端请求发布权限时，问题开始出现。一旦用户授予发布权限，“我的会话”仍显示旧的基本权限。但若我同时检查fb上的用户设置，则表明该应用程序已授予发布权限。但不知何故，在应用程序中，我没有得到 更新的accessToken

这是我为获得发布许可而做的

private void requestPublishPermissions(Session session) {
    if (session != null) {
        Session.NewPermissionsRequest newPermissionsRequest = new Session.NewPermissionsRequest(this, PERMISSION)
                // demonstrate how to set an audience for the publish permissions,
                // if none are set, this defaults to FRIENDS
                .setDefaultAudience(SessionDefaultAudience.FRIENDS)
                .setRequestCode(REAUTH_ACTIVITY_CODE);
        session.requestNewPublishPermissions(newPermissionsRequest);
    }
}
一旦用户授予了权限（当调用此方法时），仅下一个会话。此方法调用后的StatusCallback仍显示旧会话权限

我的问题: 1） 如何在发布许可被批准后立即获得刷新的accessToken？ 2） 如果（1）不可能，那么什么是正确的方法？因为来自客户的电话必须与 更新的accessToken。是否让用户等待更新的accessToken？如果是，怎么做

谢谢。

回答我自己的问题

花了好几个小时才弄明白。这里是请求读取和发布权限的逐步过程

设置Eclipse、Android、Facebook SDK 3.6 程序主要活动和静态片段 尝试实现？请求读取权限，然后请求发布权限

main活动

YourFragment.java

public类YourFragment扩展了Fragment{
公共静态字符串标记=YourFragment.class.getSimpleName（）；
私有静态最终列表权限=Arrays.asList（“发布\流，发布\操作”）；
//表示是否正在等待扩展权限的标志
private Session.StatusCallback StatusCallback=新会话StatusCallback（）；
private Session.StatusCallback publishCallback=新建publishCallback（）；
私有按钮发布；
@凌驾
CreateView上的公共视图（布局、充气机、视图组容器、捆绑包保存状态）{
视图=充气机。充气（R.layout.fragment，container，false）；
buttonLoginLogout=（按钮）视图。findViewById（R.id.buttonLoginLogout）；
publish=（按钮）view.findViewById（R.id.publish）；
//请确保在实例化片段时有会话
Session=Session.getActiveSession（）；
if（会话==null）{
如果（savedInstanceState！=null）{
session=session.restoreSession（getActivity（），null，statusCallback，savedInstanceState）；
}
if（会话==null）{
会话=新会话（getActivity（））；
}
Session.setActiveSession（Session）；
if（session.getState（）.equals（SessionState.CREATED\u TOKEN\u LOADED））{
session.openForRead（newsession.OpenRequest（this.setCallback）（statusCallback））；
}
}
onSessionStateChange（）；
返回视图；
}
@凌驾
public void onStart（）{
super.onStart（）；
Session.getActiveSession（）.addCallback（statusCallback）；
}
@凌驾
公共void onStop（）{
super.onStop（）；
Session.getActiveSession（）.removeCallback（statusCallback）；
}
@凌驾
ActivityResult上的公共void（int请求代码、int结果代码、意图数据）{
super.onActivityResult（请求代码、结果代码、数据）；
Session.getActiveSession（）.onActivityResult（getActivity（），requestCode，resultCode，data）；
}
@凌驾
SaveInstanceState上的公共无效（束超出状态）{
super.onSaveInstanceState（超出状态）；
Session=Session.getActiveSession（）；
Session.saveSession（Session，outState）；
}
私有void onSessionStateChange（）{
Session=Session.getActiveSession（）；
if（session.getPermissions（）包含（“发布操作”））{
//您在此处使用扩展权限更新了令牌
}
if（session.isOpened（））{
//你在这里有什么东西吗？例如获取accessToken、过期等。
}
否则{
}
}
public void requestPublishPermissions（活动活动、会话会话、列表权限、int requestCode）{
if（会话！=null）{
Session.NewPermissionsRequest reauthRequest=新建会话。NewPermissionsRequest（活动，权限）。setRequestCode（请求代码）；
setCallback（publishCallback）；
session.requestNewPublishPermissions（重新授权请求）；
}
}
//在片段中某个按钮的onclick调用上设置此选项
私有void openForRead（）{
Session=Session.getActiveSession（）；
如果（！session.isOpened（）&&！session.isClosed（））{
session.openForRead（newsession.OpenRequest（this.setCallback）（statusCallback））；
}
否则{
openActiveSession（getActivity（），this，true，statusCallback）；
}
}
//在片段中某个注销按钮的onclick调用上设置此选项
私有void logMeOut（）{
Session=Session.getActiveSession（）；
如果（！session.isClosed（））{
session.closeAndClearTokenInformation（）；
}
}
私有类SessionStatusCallback实现Session.StatusCallback{
@凌驾
公共无效调用（会话、会话状态、异常）{
onSessionStateChange（）；
Debug.waitForDebugger（）；
if（异常！=null）{
//汉德尔，你的例外情况在这里
Log.i（标记，exception.getMessage（））；
}
}
}
私有类PublishCallback实现Session.StatusCallback{
@凌驾
公共无效调用（会话、会话状态、异常）{
Debug.waitForDebugger（）；
onSessionStateChange（）；
if（异常！=null）{
//汉德尔，你的例外情况在这里
Log.i（标记，exception.getMessage（））；
}
}
}
}
您可能遇到的错误

  • 1）发布权限从不回调
这是最重要的 
public class YourFragmentActivity extends FragmentActivity {

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    //Static Fragment
    setContentView(R.layout.fragment_layout);
}


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

public class YourFragment extends Fragment {
public static String TAG = YourFragment.class.getSimpleName();

private static final List<String> PERMISSIONS = Arrays.asList("publish_stream, publish_actions");

// Flag to represent if we are waiting for extended permissions

private Session.StatusCallback statusCallback = new SessionStatusCallback();
private Session.StatusCallback publishCallback = new PublishCallback();

private Button publish;



@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    View view = inflater.inflate(R.layout.fragment, container, false);

    buttonLoginLogout = (Button) view.findViewById(R.id.buttonLoginLogout);
    publish = (Button) view.findViewById(R.id.publish);


            //Make Sure you have session when you instantiate fragment
    Session session = Session.getActiveSession();
    if (session == null) {
        if (savedInstanceState != null) {
            session = Session.restoreSession(getActivity(), null, statusCallback, savedInstanceState);
        }
        if (session == null) {
            session = new Session(getActivity());
        }
        Session.setActiveSession(session);
        if (session.getState().equals(SessionState.CREATED_TOKEN_LOADED)) {
            session.openForRead(new Session.OpenRequest(this).setCallback(statusCallback));
        }
    }

    onSessionStateChange();

    return view;
}

@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(getActivity(), requestCode, resultCode, data);
}

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

private void onSessionStateChange() {
    Session session = Session.getActiveSession();

    if(session.getPermissions().contains("publish_actions")){

                 //You got you updated token here with extended permissions
    }
    if (session.isOpened()) {

                 //Do you stuff here. e.g Getting accessToken, expiry etc.

    }
    else {
    }
}

public  void requestPublishPermissions(Activity activity, Session session, List<String> permissions, int requestCode) {

    if (session != null) {
        Session.NewPermissionsRequest reauthRequest = new Session.NewPermissionsRequest(activity, permissions).setRequestCode(requestCode);
        reauthRequest.setCallback(publishCallback);

        session.requestNewPublishPermissions(reauthRequest);
    }
}

    //Set this on onclick call of some button in you fragment
private void openForRead() {
    Session session = Session.getActiveSession();
    if (!session.isOpened() && !session.isClosed()) {
        session.openForRead(new Session.OpenRequest(this).setCallback(statusCallback));
    }
    else {
        Session.openActiveSession(getActivity(), this, true, statusCallback);
    }
}

    //Set this on onclick call of some logout button in you fragment 
private void logMeOut() {
    Session session = Session.getActiveSession();
    if (!session.isClosed()) {
        session.closeAndClearTokenInformation();
    }
}

private class SessionStatusCallback implements Session.StatusCallback {
    @Override
    public void call(Session session, SessionState state, Exception exception) {
        onSessionStateChange();
        Debug.waitForDebugger();
        if (exception != null){
                            //Handel your exception case here 
            Log.i(TAG, exception.getMessage());
                    }
    }
}

private class PublishCallback implements Session.StatusCallback {
    @Override
    public void call(Session session, SessionState state, Exception exception) {
        Debug.waitForDebugger();
        onSessionStateChange();
        if (exception != null){
                            //Handel your exception case here
            Log.i(TAG, exception.getMessage());
                     }
    }
}
}