Android onCompleted（）方法用户为空

嗨，我正在使用facebook登录

LandingFragment.java

@Override
    public void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        if(ConstantMethods.isNetworkAvailable()){
            GetOrCreateFacebookActiveSession(savedInstanceState);
        }
        GetKeyHash();

    }

//按钮单击侦听器

faceBookLoginButton.setOnClickListener(new onFacebookLoginListener());

//onFacebookLoginListener（）

//facebook登录 私有类onFacebookLoginListener实现OnClickListener{

@Override
public void onClick(View v) {

    if (ConstantMethods.isNetworkAvailable()) {


                hideKeyBoard();
                FacebookLoginUtility utility = new FacebookLoginUtility(getActivity());

                Session session = Session.getActiveSession();
                if (!session.isOpened()) {
                    new FacebookLoginUtility(getActivity(),LandingFragment.this).loginToFacebook(getActivity());
                } else {
                    utility.fetch_User_Data(getActivity());
                }



    } else {
        ConstantMethods.showErrorDialog(getActivity(), getResources()
                .getString(R.string.network_conn_loss));
    }

}
}

facebookloginutability.java//只是一个类而不是一个活动

在这里，我复制了我在这个类中实现的所有东西

public class FacebookLoginUtility {

    private Context mContext;
    private Session.StatusCallback statusCallback;
    public static GraphUser FBuser;
    private LandingFragment mLandingFragment;

    public FacebookLoginUtility(Context mContext) {
        super();
        this.mContext = mContext;
    }

    public FacebookLoginUtility(Context mContext,
            LandingFragment landingFragment) {
        super();
        this.mContext = mContext;
        this.mLandingFragment = landingFragment;
    }

    public void loginToFacebook(Context context) {
        if (isNetworkAvailable()) {
            Session session = Session.getActiveSession();

            // if session is in exceptional state
            if (session.getState() == SessionState.CLOSED_LOGIN_FAILED
                    || session.getState() == SessionState.OPENING) {
                session.closeAndClearTokenInformation();
            }

            if (!session.isOpened() && !session.isClosed()) {
                String[] PERMISSION_ARRAY_READ = { "email", "user_birthday" };
                List<String> PERMISSION_LIST = Arrays
                        .asList(PERMISSION_ARRAY_READ);
                session.openForRead(new Session.OpenRequest((Activity) context)
                        .setPermissions(PERMISSION_LIST).setCallback(
                                statusCallback));
            } else {
                Session.openActiveSession((Activity) context, true,
                        statusCallback);
            }
        } else {

            // showAlertDialog("Please check your internet connection!");
        }
    }

    public void fetch_User_Data(final Context mContext) {

        // request a new session with read permissions if session is opened with
        // publish permissions
        Session session = Session.getActiveSession();
        List<String> permissions = session.getPermissions();
        try {
            if (!isSubsetOf(Arrays.asList("email", "user_birthday"),
                    permissions)) {
                Session.NewPermissionsRequest newPermissionsRequest = new Session.NewPermissionsRequest(
                        (Activity) mContext, Arrays.asList("email",
                                "user_birthday"));
                session.requestNewReadPermissions(newPermissionsRequest);
            }
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        // Upgraded
        Request.newMeRequest(session, new Request.GraphUserCallback() {

            @Override
            public void onCompleted(GraphUser user, Response response) {
                // TODO Auto-generated method stub
                System.out.println("" + user);
                if (user != null) {
                    FBuser = user;
                    mLandingFragment.getFacebookUserDetails(user
                            .getInnerJSONObject().toString());
                    /*
                     * setRegisterValuesUsingFacebook(user.getInnerJSONObject()
                     * .toString());
                     */
                } else {
                    Toast.makeText(mContext, "Unable to get user profile data",
                            Toast.LENGTH_SHORT).show();
                }
            }
        }).executeAsync();

    }

    private boolean isNetworkAvailable() {
        ConnectivityManager connectivityManager = (ConnectivityManager) mContext
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetworkInfo = connectivityManager
                .getActiveNetworkInfo();
        // return activeNetworkInfo.getState() == NetworkInfo.State.CONNECTED;

        return (activeNetworkInfo != null)
                && activeNetworkInfo.isConnectedOrConnecting();
    }

    public static boolean isSubsetOf(Collection<String> subset,
            Collection<String> superset) {
        for (String string : subset) {
            if (!superset.contains(string)) {
                return false;
            }
        }
        return true;
    }

}

public类facebook登录性{
私有上下文；
private Session.StatusCallback StatusCallback；
公共静态图形用户；
私人着陆碎片；
public FaceBookLoginUtability（上下文mContext）{
超级（）；
this.mContext=mContext；
}
public FaceBookLoginUtability（上下文mContext，
着陆碎片（着陆碎片）{
超级（）；
this.mContext=mContext；
this.mLandingFragment=landingFragment；
}
public void登录到Facebook（上下文）{
if（isNetworkAvailable（））{
Session=Session.getActiveSession（）；
//如果会话处于异常状态
如果（session.getState（）==SessionState.CLOSED\u登录失败
||session.getState（）=SessionState.OPENING）{
session.closeAndClearTokenInformation（）；
}
如果（！session.isOpened（）&&！session.isClosed（））{
字符串[]权限\数组\读取={“电子邮件”，“用户\生日”}；
列表权限\u列表=数组
.asList（权限\数组\读取）；
session.openForRead（新session.OpenRequest（（活动）上下文）
.setPermissions（权限列表）.setCallback(
状态（回调）；
}否则{
Session.openActiveSession（（活动）上下文，true，
状态（回调）；
}
}否则{
//showAlertDialog（“请检查您的internet连接！”）；
}
}
公共无效获取用户数据（最终上下文mContext）{
//如果使用打开会话，则请求具有读取权限的新会话
//发布权限
Session=Session.getActiveSession（）；
List permissions=session.getPermissions（）；
试一试{
如果（！isSubsetOf（Arrays.asList（“电子邮件”，“用户生日”），
（许可证）{
Session.newpermissions请求newpermissions请求=newsession.newpermissions请求(
（活动）mContext，Arrays.asList（“电子邮件”，
"用户(生日);；
session.requestNewReadPermissions（newPermissionsRequest）；
}
}捕获（异常e1）{
//TODO自动生成的捕捉块
e1.printStackTrace（）；
}
//升级
Request.newMeRequest（会话，new Request.GraphUserCallback（）{
@凌驾
未完成公共无效（GraphUser用户，响应）{
//TODO自动生成的方法存根
System.out.println（“+”用户）；
如果（用户！=null）{
FBuser=用户；
mLandingFragment.getFacebookUserDetails（用户
.getInnerJSONObject（）.toString（））；
/*
*setRegisterValuesUsingFacebook（user.getInnerJSONObject（）用户）
*.toString（））；
*/
}否则{
Toast.makeText（mContext，“无法获取用户配置文件数据”，
吐司。长度（短）。show（）；
}
}
}).executeAsync（）；
}
专用布尔值isNetworkAvailable（）{
ConnectivityManager ConnectivityManager=（ConnectivityManager）mContext
.getSystemService（Context.CONNECTIVITY\u服务）；
NetworkInfo activeNetworkInfo=connectivityManager
.getActiveNetworkInfo（）；
//返回activeNetworkInfo.getState（）==NetworkInfo.State.CONNECTED；
返回（activeNetworkInfo！=null）
&&activeNetworkInfo.isConnectedOrConnecting（）；
}
公共静态布尔isSubsetOf（集合子集，
收集超集）{
for（字符串：子集）{
如果（！superset.contains（string））{
返回false；
}
}
返回true；
}
}

在这个类的onCompleted（）方法中，user对象得到null值，因此我无法获得用户的详细信息

根据上述解释,

我正在尝试从Fragment登录

我为登录编写了单独的类。因为我需要在我的应用程序的其他页面中重用它。（在应用程序的多个页面中提供了登录选项）

---

如何获取用户详细信息？

从未调用过fetch\u user\u data（）。因此会话始终关闭。fetch\u user\u data（）仅从登录按钮上的单击侦听器调用？这是Facebook SDK中的登录按钮吗？@MingLi No。这是自定义按钮。您是否在活动或片段（正在进行登录）中重写onActivityResult方法然后将结果传递给活动会话？如果没有它，SDK将无法从打开的请求中获得结果。请参阅Facebook开发者网站上的登录教程-您可以在UiLifecycleHelper类上调用onActivityResult方法，或者直接在session.getActiveSession上调用onActivityResult方法。