Java 类com.facebook.login.LoginResult 实例源码

@Override
        public void onSuccess(com.facebook.login.LoginResult loginResult) {
            Profile facebookProfile = Profile.getCurrentProfile();
            if (facebookProfile == null) {
                String errorMsg = InfoFromFacebookActivity.this.getResources().getString(R.string.facebook_error);
                errorMsg = errorMsg + ".";
                Snackbar.make(textViewFacebookName, errorMsg, Snackbar.LENGTH_LONG).show();
                textViewFacebookName.setText(errorMsg);
            } else {
                facebookProfilePhoto.setProfileId(facebookProfile.getId());
                textViewFacebookName.setText(facebookProfile.getName());

                buttonAck.setEnabled(true);
                buttonSwitch.setVisibility(Button.VISIBLE);
            }

            // TODO: Do not store access token - it is a security issue storing this
            // TODO and appears to be of no benefit.
//                AccessToken token = loginResult.getAccessToken();
//                DataHolder data = DataHolder.getInstance(InfoFromFacebookActivity.this.getApplicationContext());
//                data.setFacebookToken(token.getToken());
//                data.persist();
        }

public FacebookHelper(@NonNull FacebookListener facebookListener) {
  mListener = facebookListener;
  mCallBackManager = CallbackManager.Factory.create();
  FacebookCallback<LoginResult> mCallBack = new FacebookCallback<LoginResult>() {
    @Override public void onSuccess(LoginResult loginResult) {
      mListener.onFbSignInSuccess(loginResult.getAccessToken().getToken(),
          loginResult.getAccessToken().getUserId());
    }

    @Override public void onCancel() {
      mListener.onFbSignInFail("User cancelled operation");
    }

    @Override public void onError(FacebookException e) {
      mListener.onFbSignInFail(e.getMessage());
    }
  };
  LoginManager.getInstance().registerCallback(mCallBackManager, mCallBack);
}

@OnClick(R.id.fb_login)
public void setUpFacebookLoginButton() {
    LoginManager.getInstance().logInWithReadPermissions(this, Arrays.asList("email", "public_profile"));
    LoginManager.getInstance().registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            handleFacebookAccessToken(loginResult.getAccessToken());
        }

        @Override
        public void onCancel() {

        }

        @Override
        public void onError(FacebookException error) {
            if(!isNetworkConnected()){
                Snackbar.make(findViewById(android.R.id.content),"please check internet connection"
                        ,Snackbar.LENGTH_SHORT).show();
            }else{
                Snackbar.make(findViewById(android.R.id.content),"unexpected error,please try again later"
                        ,Snackbar.LENGTH_SHORT).show();
            }
        }
    });
}

protected void registerFacebookCallback() {
    LoginManager.getInstance().registerCallback(facebookCallbackManager,
            new FacebookCallback<LoginResult>() {

                @Override
                public void onSuccess(LoginResult loginResult) {
                    // App code
                    Log.d(TAG, "Login Success");
                    handleFacebookAccessToken(loginResult.getAccessToken());
                }

                @Override
                public void onCancel() {
                    // App code
                    Log.d(TAG, "Login canceled");
                }

                @Override
                public void onError(FacebookException exception) {
                    // App code
                    Log.d(TAG, "Login error");
                }
            });
}

private void setupFacebookLogin() {
    mFacebookCallbackManager = CallbackManager.Factory.create();

    binding.facebookButton.setReadPermissions("email","public_profile");

    // Callback registration
    binding.facebookButton.registerCallback(mFacebookCallbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            firebaseAuthWithFacebook(loginResult.getAccessToken());
        }

        @Override
        public void onCancel() {
            Toast.makeText(ProfileActivity.this, "Facebook Authentication cancelled.", Toast.LENGTH_SHORT).show();
        }

        @Override
        public void onError(FacebookException exception) {
            Toast.makeText(ProfileActivity.this, "Facebook Authentication failed.", Toast.LENGTH_SHORT).show();
            Timber.e(exception);
        }
    });
}

public LoginFacebook(LoginButton login, Activity context, PreferencesShared pref, final Intent intent) {
    callbackManager = CallbackManager.Factory.create();
    this.context = context;
    preferencesShared = pref;
    login.setReadPermissions(Arrays.asList("public_profile", "user_friends"));
    login.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            //Log.d("facebook", "succes" + loginResult.getAccessToken().getToken() + "id" + loginResult.getAccessToken().getExpires() + "data" + loginResult.getAccessToken().getUserId());
            conectedwithFacebook(loginResult.getAccessToken().getToken(),intent);
        }

        @Override
        public void onCancel() {
            Log.d("intra","facebook");
        }

        @Override
        public void onError(FacebookException error) {
            Log.d("facebook", "error" + error.toString());
        }

    });
}

@Override
public void onSuccess(LoginResult loginResult) {
    GraphRequest request = GraphRequest.newMeRequest(
            loginResult.getAccessToken(),
            new GraphRequest.GraphJSONObjectCallback() {
                @Override
                public void onCompleted(JSONObject object, GraphResponse response) {
                    String socialId = null, name = null;
                    try {
                        socialId = object.getString("id");
                        name = object.getString("name");
                    }catch (Exception e){}

                    register(socialId, name);
                }
            });
    Bundle parameters = new Bundle();
    parameters.putString("fields", "id,name");
    request.setParameters(parameters);
    request.executeAsync();
}

public static FacebookCallback<LoginResult> loginResultCallback(final MethodChannel.Result result, final OnLoginSuccessListener onLoginSuccess) {
    return new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            onLoginSuccess.onLoginResult(loginResult);
        }

        @Override
        public void onCancel() {
            result.error(TAG, "Cancelled", null);
        }

        @Override
        public void onError(FacebookException exception) {
            result.error(TAG, exception.getMessage(), null);
        }
    };
}

private void facebookLogin(LoginResult loginResult){
    GraphRequest request = GraphRequest.newMeRequest(
            loginResult.getAccessToken(),
            new GraphRequest.GraphJSONObjectCallback(){
                @Override
                public void onCompleted(JSONObject object, GraphResponse response){
                    JSONObject jsonObject = response.getJSONObject();
                    UserAccountControl userAccountControl = UserAccountControl
                            .getInstance(getApplicationContext());
                    userAccountControl.authenticateLoginFb(object);
                    userAccountControl.logInUserFromFacebook(jsonObject);
                }
            });

    Bundle parameters = new Bundle();
    parameters.putString("fields", "id,name,email,gender");
    request.setParameters(parameters);
    request.executeAsync();

}

private void facebookLogin(LoginResult loginResult) {
    GraphRequest request = GraphRequest.newMeRequest(
            loginResult.getAccessToken(),
            new GraphRequest.GraphJSONObjectCallback() {
                @Override
                public void onCompleted(JSONObject object, GraphResponse response) {

                    UserAccountControl userAccountControl = UserAccountControl
                            .getInstance(getApplicationContext());
                    userAccountControl.authenticateLoginFb(object);
                }
            });

    Bundle parameters = new Bundle();
    parameters.putString("fields", "id,name,email,gender");
    request.setParameters(parameters);
    request.executeAsync();
}

/**
 * Register call back manager.
 *
 * @param activity the activity
 */
private void registerCallBackManager(final Activity activity) {
    LoginManager.getInstance()
            .registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
                @Override
                public void onSuccess(LoginResult loginResult) {
                    mLoginResult = loginResult;
                    getUserProfile(activity);
                }

                @Override
                public void onCancel() {
                    mFacebookLoginResultCallBack.onFacebookLoginCancel();
                }

                @Override
                public void onError(FacebookException error) {
                    mFacebookLoginResultCallBack.onFacebookLoginError(error);
                }
            });
}

/**
 * Register call back manager to Google log in button.
 *
 * @param activity    the activity
 * @param loginButton the login button
 */
private void registerCallBackManager(final Activity activity, LoginButton loginButton) {
    loginButton.registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            mLoginResult = loginResult;
            getUserProfile(activity);
        }

        @Override
        public void onCancel() {
            mFacebookLoginResultCallBack.onFacebookLoginCancel();
        }

        @Override
        public void onError(FacebookException error) {
            mFacebookLoginResultCallBack.onFacebookLoginError(error);
        }
    });
}

@Override
public void setCallbackToLoginFacebookButton() {

    callbackManager = CallbackManager.Factory.create();

    LoginManager.getInstance().registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            Bundle param = new Bundle();
            param.putString("fields", "id, email");
            facebookLink(loginResult);
        }

        @Override
        public void onCancel() {

        }

        @Override
        public void onError(FacebookException error) {
            Logger.logExceptionToFabric(error);
        }
    });
}

void initializeFacebookLogin() {
    // Initialize Facebook Login button
    mCallbackManager = CallbackManager.Factory.create();
    LoginButton loginButton = (LoginButton) findViewById(R.id.button_facebook_login);
    loginButton.setReadPermissions("email", "public_profile", "user_posts", "user_photos");
    loginButton.registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            Log.d(TAG, "facebook:onSuccess:" + loginResult);
            handleFacebookAccessToken(loginResult.getAccessToken());
        }

        @Override
        public void onCancel() {
            Log.d(TAG, "facebook:onCancel");
            // ...
        }

        @Override
        public void onError(FacebookException error) {
            Log.w(TAG, "facebook:onError", error);
        }
    });
}

@Override
public void onFacebookLoginBntClick(LoginButton loginButton) {
        mCallbackManager = CallbackManager.Factory.create();
        loginButton.setReadPermissions("email", "public_profile");
        loginButton.registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
            @Override
            public void onSuccess(LoginResult loginResult) {
                handleFacebookAccessToken(loginResult.getAccessToken());
            }

            @Override
            public void onCancel() {
            }

            @Override
            public void onError(FacebookException error) {
                getView().showSnackBar(error.getMessage());
            }
        });
}

@Override
public void onSuccess(LoginResult loginResult) {
    final String fbAccessToken = loginResult.getAccessToken().getToken();
    PreferenceManager.getDefaultSharedPreferences(context).edit().putString(TOKEN_FB_KEY,fbAccessToken);
    Bundle parameters = new Bundle();
    parameters.putString("fields", "id,name,email");
    GraphRequest request = GraphRequest.newMeRequest(loginResult.getAccessToken(), new GraphRequest.GraphJSONObjectCallback() {
        @Override
        public void onCompleted(JSONObject object, GraphResponse response) {
            if (onFacebookEvent != null) {
                InfoSocial infoSocial = new InfoSocial();
                infoSocial.setAccessToken(fbAccessToken);
                infoSocial.setName(object.optString("name"));
                infoSocial.setEmail(object.optString("email"));
                infoSocial.setUserId(object.optString("id"));
                onFacebookEvent.onFacebookSuccess(infoSocial);
            }
        }
    });
    request.setParameters(parameters);
    request.executeAsync();
}

private void configureFacebookLogin(){
    FacebookSdk.sdkInitialize(context.getApplicationContext());
    ssFacebookCallbackManager = CallbackManager.Factory.create();
    LoginManager.getInstance().registerCallback(ssFacebookCallbackManager,
            new FacebookCallback<LoginResult>() {
                @Override
                public void onSuccess(LoginResult loginResult) {
                    handleFacebookAccessToken(loginResult.getAccessToken());
                }

                @Override
                public void onCancel() {
                    // TODO: Handle unsuccessful / cancel
                }

                @Override
                public void onError(FacebookException exception) {
                    loginFailed(exception.getMessage());
                }
            });
}

private void initFaceBookLogin() {
    callbackManager = CallbackManager.Factory.create();
    btnLoginFacebook.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            showDialog();
            presenter.requestFacebook(loginResult);
            LogUtil.e2(loginResult.getAccessToken().toString());
        }

        @Override
        public void onCancel() {

        }

        @Override
        public void onError(FacebookException error) {

        }
    });
}

@Override
public void requestFacebook(LoginResult loginResult) {
    AccessToken accessToken = loginResult.getAccessToken();
    NetRequest.Instance().facebookLogin(accessToken.getUserId(), MD5Util.getMD5(accessToken.getUserId()),
            new NetRequest.RequestListener<User>() {
                @Override
                public void success(User user) {
                    view.callLoginSuccess();
                }

                @Override
                public void error(String err) {
                    view.callLoginFail(err);
                }
            });

}

@Override
public void onSuccess(LoginResult loginResult) {
    Timber.d("facebook:onSuccess:permissions" + loginResult.getRecentlyGrantedPermissions());
    AuthCredential credential = FacebookAuthProvider.getCredential(loginResult.getAccessToken().getToken());
    firebaseAuth.signInWithCredential(credential)
            .addOnCompleteListener(new OnCompleteListener<AuthResult>() {
                @Override
                public void onComplete(@NonNull Task<AuthResult> task) {
                    if (!task.isSuccessful()) {
                        Timber.d("onComplete:failed:" + task.getException());
                        return;
                    }
                    Timber.d("onComplete:success:" + task.isSuccessful());
                    sessionManager.saveUserInfo();
                    setupLoginState();
                }
            });
}

private void setFacebookRule() {
    callbackManager = CallbackManager.Factory.create();
    LoginManager.getInstance().registerCallback(callbackManager,
            new FacebookCallback<LoginResult>() {
                @Override
                public void onSuccess(LoginResult loginResult) {
                    EventBus.getDefault().post(MessageEvent.UPDATE_FACEBOOK_PROFILE);
                }

                @Override
                public void onCancel() {
                    Log.d("Teste", "deu errp");
                }

                @Override
                public void onError(FacebookException exception) {
                    Log.d("ErrorF", exception.toString());
                }
            }
    );

    Profile profile = Profile.getCurrentProfile();

    if (profile != null) {
        this.sidebar.showHideLogoff(true);
    } else {
        this.sidebar.showHideLogoff(false);
    }

}

private void registerFacebookLoginManagerCallback() {
        LoginManager.getInstance().registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
            @Override
            public void onSuccess(LoginResult loginResult) {
                connectFacebookAccount();
            }

            @Override
            public void onCancel() {
                PDAbraLogEvent.log(PDAbraConfig.ABRA_EVENT_CANCELLED_FACEBOOK_LOGIN, null);
//                PDLog.d(PDUISocialLoginFragment.class, "Facebook Login onCancel()");
//                if (getActivity() != null) {
//                    PDUIDialogUtils.showBasicOKAlertDialog(getActivity(), R.string.pd_common_facebook_login_cancelled_title_text, R.string.pd_common_facebook_login_cancelled_message_text);
//                }
            }

            @Override
            public void onError(FacebookException error) {
                PDLog.d(PDUISocialLoginFragment.class, "Facebook Login onError(): " + error.getMessage());
                if (getActivity() != null) {
                    PDUIDialogUtils.showBasicOKAlertDialog(getActivity(), R.string.pd_common_sorry_text, error.getMessage());
                }
            }
        });
    }

protected void registerFacebookCallback() {
    LoginManager.getInstance().registerCallback(facebookCallbackManager,
            new FacebookCallback<LoginResult>() {

                @Override
                public void onSuccess(LoginResult loginResult) {
                    // App code
                    Log.d(TAG, "Login Success");
                    handleFacebookAccessToken(loginResult.getAccessToken());
                }

                @Override
                public void onCancel() {
                    // App code
                    Log.d(TAG, "Login canceled");
                }

                @Override
                public void onError(FacebookException exception) {
                    // App code
                    Log.d(TAG, "Login error");
                }
            });
}

private void facebookManger() {
    lBFrgLoginFacebook.setReadPermissions("email");
    lBFrgLoginFacebook.setFragment(this);
    lBFrgLoginFacebook.registerCallback(callbackManager,
            new FacebookCallback<LoginResult>() {
                @Override
                public void onSuccess(LoginResult loginResult) {
                    presenter.doLoginWithFacebook(loginResult);
                    Timber.e(loginResult.toString());
                }

                @Override
                public void onCancel() {
                }

                @Override
                public void onError(FacebookException exception) {
                    EventBus.getDefault().post(new EventSnackBar().withMessage(getString(R.string.error_facebook_connection)));
                }
            });
}

private void registerFacebookCallback() {
  final PublishSubject<String> fbAccessToken = this.facebookAccessToken;
  final BehaviorSubject<FacebookException> fbAuthError = this.facebookAuthorizationError;

  this.callbackManager = CallbackManager.Factory.create();

  LoginManager.getInstance().registerCallback(this.callbackManager, new FacebookCallback<LoginResult>() {
    @Override
    public void onSuccess(final @NonNull LoginResult result) {
      fbAccessToken.onNext(result.getAccessToken().getToken());
    }

    @Override
    public void onCancel() {
      // continue
    }

    @Override
    public void onError(final @NonNull FacebookException error) {
      if (error instanceof FacebookAuthorizationException) {
        fbAuthError.onNext(error);
      }
    }
  });
}

private void registerFacebookCallback() {
  LoginManager.getInstance()
      .registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override public void onSuccess(LoginResult loginResult) {
          FacebookModel facebookModel = createFacebookModel(loginResult);
          mActionsListener.syncFacebook(facebookModel);
        }

        @Override public void onCancel() {
        }

        @Override public void onError(FacebookException error) {
          Logger.e(this.getClass()
              .getName(), error.getMessage());
        }
      });
}

public void navigateToFacebookSignUpForResult(Collection<String> permissions) {
  facebookLoginManager.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
    @Override public void onSuccess(LoginResult loginResult) {
      facebookLoginSubject.call(
          new FacebookLoginResult(loginResult, FacebookLoginResult.STATE_SUCCESS, null));
    }

    @Override public void onCancel() {
      facebookLoginSubject.call(
          new FacebookLoginResult(null, FacebookLoginResult.STATE_CANCELLED, null));
    }

    @Override public void onError(FacebookException error) {
      facebookLoginSubject.call(
          new FacebookLoginResult(null, FacebookLoginResult.STATE_ERROR, error));
    }
  });
  facebookLoginManager.logInWithReadPermissions(activityNavigator.getActivity(), permissions);
}

/**
 * Login facebook to get the {@link LoginResult}.
 *
 * @param activity    the activity which is starting the login process
 * @param publish     need publish permission or not
 * @param permissions the requested permissions
 * @return the {@link Flowable} of {@link LoginResult} of this login process
 */
public Flowable<LoginResult> loginFacebook(Activity activity, boolean publish,
    List<String> permissions) {
    if (mFbManager == null) {
        mFbManager = com.facebook.login.LoginManager.getInstance();
    }
    return Flowable.create(new FacebookSubscriber(this), BackpressureStrategy.DROP)
        .doOnSubscribe(subscription -> {
            mFbManager.logOut();
            if (publish) {
                mFbManager.logInWithPublishPermissions(activity, permissions);
            } else {
                mFbManager.logInWithReadPermissions(activity, permissions);
            }
        })
        .doOnTerminate(() -> {
            mFbManager = null;
            mFacebookCallback = null;
            mCallbackManager = null;
        });
}

@Override public void subscribe(FlowableEmitter<LoginResult> emitter) throws Exception {
    mCallback = new FacebookCallback<LoginResult>() {
        @Override public void onSuccess(LoginResult result) {
            if (!emitter.isCancelled()) {
                emitter.onNext(result);
                emitter.onComplete();
            }
        }

        @Override public void onCancel() {
            if (!emitter.isCancelled()) {
                emitter.onError(new LoginException(LoginException.LOGIN_CANCELED));
            }
        }

        @Override public void onError(FacebookException error) {
            if (!emitter.isCancelled()) {
                emitter.onError(new LoginException(LoginException.FACEBOOK_ERROR, error));
            }
        }
    };
    mRxLogin.registerCallback(mCallback);
}

@Override
public void subscribe(ObservableEmitter<LoginResult> emitter) throws Exception {
    if (sessionManager.isLoggedIn()) {
        LoginResult loginResult = sessionManager.createLastLoginResult();
        emitter.onNext(loginResult);
        emitter.onComplete();
        return;
    }
    List<String> mPermissions = simpleFacebookConfiguration.getReadPermissions();
    if (mPermissions != null) {
        mLoginButton.setReadPermissions(mPermissions);
    }

    // Sets the fragment that contains this control.
    // This allows the button to be embedded inside a Fragment, and will allow the fragment
    // to receive the {@link Fragment#onActivityResult(int, int, android.content.Intent)
    // onActivityResult} call rather than the Activity.
    if (mFragment != null) {
        mLoginButton.setFragment(mFragment.get());
    }

    // set observableEmitter
    sessionManager.setCallbackAsLoginWithButton(emitter);
}

private void addLoginButton() {
    LoginButton loginButton = (LoginButton) this.findViewById(R.id.login_button);
    loginButton.setReadPermissions(Arrays.asList("email", "user_friends",
            "public_profile", "user_birthday"));
    loginButton.registerCallback(fbCallbackManager, new FacebookCallback<LoginResult>() {

        private ProfileTracker mProfileTracker;

        @Override
        public void onSuccess(LoginResult loginResult) {

        }

        @Override
        public void onCancel() {

        }

        @Override
        public void onError(FacebookException error) {

        }
    });
}

private void registerCallback() {
    LoginManager.getInstance().registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            getUserEmail(loginResult.getAccessToken());
        }

        @Override
        public void onCancel() {
            Snackbar.make(mRootView, R.string.facebook_cancel, Snackbar.LENGTH_SHORT).show();
        }

        @Override
        public void onError(FacebookException error) {
            Snackbar.make(mRootView, error.getLocalizedMessage(), Snackbar.LENGTH_SHORT).show();
        }
    });
}

private CallbackManager setupFacebookSignIn() {
    CallbackManager callbackManager = CallbackManager.Factory.create();
    fbSignInButton.setReadPermissions("email", "public_profile");

    fbSignInButton.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            Log.d("MAPP", "facebook:onSuccess: " + loginResult);
            handleFacebookAccessToken(loginResult.getAccessToken());
        }

        @Override
        public void onCancel() {
            Log.d("MAPP", "facebook:onCancel");
            // ...
        }

        @Override
        public void onError(FacebookException error) {
            Log.d("MAPP", "facebook:onError", error);
            // ...
        }
    });

    return callbackManager;
}

@Override
public void initFbLoginButton() {
    mCallbackManager = CallbackManager.Factory.create();
    mLoginFbButton.setReadPermissions("email", "public_profile");
    mLoginFbButton.registerCallback(mCallbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            Timber.d("facebook:onSuccess:" + loginResult);
            mPresenter.handleFacebookAccessToken(loginResult.getAccessToken());
        }

        @Override
        public void onCancel() {
            Timber.d("facebook:onCancel");
        }

        @Override
        public void onError(FacebookException error) {
            Timber.d("facebook:onError", error);
        }
    });
}

protected void getLoginDetails(LoginButton login_button) {

        // Callback registration
        login_button.registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
            @Override
            public void onSuccess(LoginResult login_result) {
                getUserInfo(login_result);
            }

            @Override
            public void onCancel() {
                // code for cancellation
            }

            @Override
            public void onError(FacebookException exception) {
                //  code to handle error
            }
        });
    }

private void registerFacebookCallback() {
    LoginManager.getInstance().registerCallback(FacebookManager.getInstance().getCallbackManager(), new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            fetchProfile();
        }

        @Override
        public void onCancel() {

        }

        @Override
        public void onError(FacebookException error) {
        }
    });
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    callbackManager = CallbackManager.Factory.create();
    LoginManager.getInstance().registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            Logger.d("onSuccess");
            onFaceBookLoginSuccess(loginResult);
        }

        @Override
        public void onCancel() {
            Logger.d("onCancel");
            onFaceBookLoginCancel();
        }

        @Override
        public void onError(FacebookException error) {
            Logger.d("onError");
            onFaceBookLoginError(error);
        }
    });
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    callbackManager = CallbackManager.Factory.create();
    LoginManager.getInstance().registerCallback(callbackManager, new FacebookCallback<LoginResult>() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            Logger.d("onSuccess");
            onFaceBookLoginSuccess(loginResult);
        }

        @Override
        public void onCancel() {
            Logger.d("onCancel");
            onFaceBookLoginCancel();
        }

        @Override
        public void onError(FacebookException error) {
            Logger.d("onError");
            onFaceBookLoginError(error);
        }
    });
}

private FacebookApi.Callback createFacebookCallback() {
    final AuthCallback callback = getSafeCallback();
    return new FacebookApi.Callback() {
        @Override
        public void onSuccess(LoginResult loginResult) {
            if (loginResult.getRecentlyDeniedPermissions().isEmpty()) {
                requestAuth0Token(loginResult.getAccessToken().getToken());
            } else {
                Log.w(TAG, "Some permissions were not granted: " + loginResult.getRecentlyDeniedPermissions().toString());
                callback.onFailure(new AuthenticationException("Some of the requested permissions were not granted by the user."));
            }
        }

        @Override
        public void onCancel() {
            Log.w(TAG, "User cancelled the log in dialog");
            callback.onFailure(new AuthenticationException("User cancelled the authentication consent dialog."));
        }

        @Override
        public void onError(FacebookException error) {
            Log.e(TAG, "Error on log in: " + error.getMessage());
            callback.onFailure(new AuthenticationException(error.getMessage()));
        }
    };
}

@Override
public void onSuccess(final LoginResult loginResult) {

    if (loginResult.getRecentlyGrantedPermissions().contains("email")) {
        GraphRequest.newMeRequest(
                loginResult.getAccessToken(), new GraphRequest.GraphJSONObjectCallback() {
                    @Override
                    public void onCompleted(JSONObject me, GraphResponse response) {
                        if (response.getError() != null) {
                            Toast.makeText(getActivity(), getString(R.string.signin_fail_error), Toast.LENGTH_SHORT).show();
                        } else {
                            onFacebookLogin(loginResult.getAccessToken().getToken());
                        }
                    }
                }).executeAsync();
    } else {
        Toast.makeText(getActivity(), getString(R.string.signin_fail_error), Toast.LENGTH_SHORT).show();
    }


}