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

@Override
public void startLogin(Activity activity) {
    sCallbackManager = CallbackManager.Factory.create();
    LoginManager loginManager = LoginManager.getInstance();
    loginManager.registerCallback(sCallbackManager, this);

    List<String> permissionsList = new ArrayList<>(mScopes);

    // Ensure we have email and public_profile scopes
    if (!permissionsList.contains(EMAIL)) {
        permissionsList.add(EMAIL);
    }

    if (!permissionsList.contains(PUBLIC_PROFILE)) {
        permissionsList.add(PUBLIC_PROFILE);
    }

    // Log in with permissions
    loginManager.logInWithReadPermissions(activity, permissionsList);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();
    if (id == R.id.action_logout) {
        sharedPref.setUserId("");
        sharedPref.setLoginStatus(false);
        sharedPref.setUserRollno("");
        sharedPref.setUserEmail("");
        sharedPref.setUserPicUrl("");
        sharedPref.setUserName("");
        LoginManager.getInstance().logOut();
        Intent intent = new Intent(MainActivity.this,LoginActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        startActivity(intent);
        finish();
        return true;
    }
    return super.onOptionsItemSelected(item);
}

/**
 * Unauthenticate from Firebase and from providers where necessary.
 */
private void logout() {
    if (this.mAuthData != null) {
        /* logout of Firebase */
        mFirebaseRef.unauth();
        /* Logout of any of the Frameworks. This step is optional, but ensures the user is not logged into
         * Facebook/Google+ after logging out of Firebase. */
        if (this.mAuthData.getProvider().equals("facebook")) {
            /* Logout from Facebook */
            LoginManager.getInstance().logOut();
        } else if (this.mAuthData.getProvider().equals("google")) {
            /* Logout from Google+ */
            if (mGoogleApiClient.isConnected()) {
                Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
                mGoogleApiClient.disconnect();
            }
        }
        /* Update authenticated user and show login buttons */
        setAuthenticatedUser(null);
    }
}

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);
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();

   if (id == R.id.action_contact_us) {
        contactUs();
        return true;
    }else if (id == R.id.action_logout) {
        //facebook logout
        LoginManager.getInstance().logOut();
        //firebase logout
        FirebaseAuth.getInstance().signOut();
        logout = true;
        startActivity(new Intent(this,LoginActivity.class));
        return true;
    }else if (id == R.id.item_samplebadge) {
        Intent intent = new Intent(this,ShoppingCardActivity.class);
        intent.putParcelableArrayListExtra("order",cardItems);
        startActivity(intent);

        return true;
    }

    return super.onOptionsItemSelected(item);
}

@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();
            }
        }
    });
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (!FacebookSdk.isInitialized()) {
        FacebookSdk.sdkInitialize(getApplicationContext());
        AppEventsLogger.activateApp(getActivity().getApplication());
    }
    // Initialize Firebase Auth
    fireBaseAuth = FirebaseAuth.getInstance();
    fireBaseAuth.signOut();

    facebookCallbackManager = CallbackManager.Factory.create();
    registerFirebase();
    registerFacebookCallback();
    LoginManager.getInstance().logInWithReadPermissions(this, Arrays.asList("email", "public_profile"));
}

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");
                }
            });
}

/**
 * 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);
                }
            });
}

/**
 * Facebook sign out
 */
public void signOut(PublishSubject<RxStatus> statusSubject) {
    LoginManager.getInstance().logOut();
    // delete current user
    deleteCurrentUser();
    statusSubject.onNext(new RxStatus(
            CommonStatusCodes.SUCCESS,
            getString(R.string.status_success_log_out_message)
    ));
    statusSubject.onCompleted();
}

@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);
        }
    });
}

public void logout() {
    if (AccessToken.getCurrentAccessToken() != null) {
        LoginManager.getInstance().logOut();
        Logger.printInfo(LOG_TAG, "Loged out from facebook");
    }
    if (Twitter.getSessionManager().getActiveSession() != null) {
        Twitter.getSessionManager().clearActiveSession();
        Twitter.logOut();
        Logger.printInfo(LOG_TAG, "Loged out from twitter");
    }
    if (VKSdk.isLoggedIn()) {
        VKSdk.logout();
        Logger.printInfo(LOG_TAG, "Loged out from vk");
    }
    Prefs.remove(SyncMaster.GLOBAL_TOKEN);
    userProfile = new UserProfile();
}

@Override
public void endSession() {
    if (AccessToken.getCurrentAccessToken() != null) {
        LoginManager.getInstance().logOut();
    }

    TwitterSession twitterSession = TwitterCore.getInstance().getSessionManager().getActiveSession();
    if (twitterSession != null) {
        clearCookies(getApplicationContext());
        Twitter.getSessionManager().clearActiveSession();
        Twitter.logOut();
    }

    startActivity(LoginActivity.makeIntent(this));
    finish();
}

@Override
public void onCompleted(JSONObject object, GraphResponse response) {
  try {
    SocialUser user = new SocialUser();
    user.userId = object.getString("id");
    user.accessToken = AccessToken.getCurrentAccessToken().getToken();
    user.photoUrl = String.format(PHOTO_URL, user.userId);
    SocialUser.Profile profile = new SocialUser.Profile();
    profile.email = object.has("email")? object.getString("email") : "";
    profile.name = object.has("name")? object.getString("name"): "";
    profile.pageLink = object.has("link")? object.getString("link"): "";
    user.profile = profile;
    SocialLoginManager.getInstance(this).onLoginSuccess(user);
  } catch (JSONException e) {
    SocialLoginManager.getInstance(this).onLoginError(e.getCause());
  }

  LoginManager.getInstance().logOut();

  finish();
}

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 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());
                }
            }
        });
    }

@Override
public void failure(int statusCode, Exception e) {
    PDLog.d(PDUISocialMultiLoginFragment.class, "failed register with social a/c: statusCode=" + statusCode + ", message=" + e.getMessage());

    if (isFacebook)
        LoginManager.getInstance().logOut();

    mProgressFacebook.setVisibility(View.GONE);
    mFacebookLoginButton.setVisibility(View.VISIBLE);
    mTwitterLoginButton.setVisibility(View.VISIBLE);
    mInstaLoginButton.setVisibility(View.VISIBLE);
    mFacebookLoginButton.setText(R.string.pd_log_in_with_facebook_text);
    mTwitterLoginButton.setText(R.string.pd_log_in_with_twitter_text);
    mFacebookLoginButton.setText(R.string.pd_log_in_with_instagram_text);

    new AlertDialog.Builder(getActivity())
            .setTitle(R.string.pd_common_sorry_text)
            .setMessage("An error occurred while registering. Please try again")
            .setPositiveButton(android.R.string.ok, null)
            .create()
            .show();
}

/**
 * Facebook
 */
private void loginFacebook() {
    if (PDLocationManager.isGpsEnabled(getActivity())) {
        LoginManager.getInstance().logInWithReadPermissions(PDUISocialMultiLoginFragment.this, Arrays.asList(PDSocialUtils.FACEBOOK_READ_PERMISSIONS));
    } else {
        new AlertDialog.Builder(getActivity())
                .setTitle(R.string.pd_location_disabled_title_text)
                .setMessage(R.string.pd_location_disabled_message_text)
                .setNegativeButton(android.R.string.no, null)
                .setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        PDLocationManager.startLocationSettingsActivity(getActivity());
                    }
                })
                .create().show();
    }
}

private void disconnectFacebook() {
    PDAPIClient.instance().disconnectFacebookAccount(AccessToken.getCurrentAccessToken().getToken(), AccessToken.getCurrentAccessToken().getUserId(), new PDAPICallback<PDUser>() {
        @Override
        public void success(PDUser pdUser) {
            PDUtils.updateSavedUser(pdUser);
            LoginManager.getInstance().logOut();
            Toast.makeText(PDUISettingsActivity.this, "Facebook disconnected.", Toast.LENGTH_SHORT).show();
            abraLog(PDAbraConfig.ABRA_EVENT_LOGOUT, PDAbraConfig.ABRA_PROPERTYVALUE_SOCIAL_NETWORK_FACEBOOK);
        }

        @Override
        public void failure(int statusCode, Exception e) {
            PDLog.d(PDUISettingsActivity.class, "disconnectFacebook:error: " + statusCode + " msg: " + e.getLocalizedMessage());
        }
    });
}

public static void logout(@NonNull Context context) {
        // Facebook Logout
        LoginManager.getInstance().logOut();

        // Clear Shared Preferences
//        PDPreferencesUtils.clearPrefs(context);

        // Clear some DB data
        Realm realm = Realm.getDefaultInstance();
        realm.beginTransaction();

        RealmResults<PDRealmUserDetails> userResults = realm.where(PDRealmUserDetails.class).findAll();
        userResults.deleteAllFromRealm();

        RealmResults<PDRealmUserFacebook> fbResults = realm.where(PDRealmUserFacebook.class).findAll();
        fbResults.deleteAllFromRealm();

        realm.commitTransaction();
        realm.close();

        // Broadcast to update rewards / wallet / etc
        context.sendBroadcast(new Intent(PDUIRewardsFragment.PD_LOGGED_IN_RECEIVER_FILTER));
    }

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (!FacebookSdk.isInitialized()) {
        FacebookSdk.sdkInitialize(getApplicationContext());
        AppEventsLogger.activateApp(getActivity().getApplication());
    }
    // Initialize Firebase Auth
    fireBaseAuth = FirebaseAuth.getInstance();
    fireBaseAuth.signOut();

    facebookCallbackManager = CallbackManager.Factory.create();
    registerFirebase();
    registerFacebookCallback();
    LoginManager.getInstance().logInWithReadPermissions(this, Arrays.asList("email", "public_profile"));
}

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 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 AccountNavigator(FragmentNavigator fragmentNavigator, AptoideAccountManager accountManager,
    ActivityNavigator activityNavigator, LoginManager facebookLoginManager,
    CallbackManager callbackManager, GoogleApiClient client,
    PublishRelay<FacebookLoginResult> facebookLoginSubject, String defaultStore,
    String defaultTheme, String recoverPasswordUrl) {
  this.fragmentNavigator = fragmentNavigator;
  this.accountManager = accountManager;
  this.activityNavigator = activityNavigator;
  this.facebookLoginManager = facebookLoginManager;
  this.callbackManager = callbackManager;
  this.client = client;
  this.facebookLoginSubject = facebookLoginSubject;
  this.defaultStore = defaultStore;
  this.defaultTheme = defaultTheme;
  this.recoverPasswordUrl = recoverPasswordUrl;
}

protected void signIn(AuthCredential credential) {
    mAuth.signInWithCredential(credential).addOnCompleteListener(new OnCompleteListener<AuthResult>() {
        @Override
        public void onComplete(@NonNull Task<AuthResult> task) {
            if (!task.isSuccessful()) {
                Exception exception = task.getException();
                if (exception != null) {
                    String errorText;
                    if (exception instanceof FirebaseAuthUserCollisionException) {
                        errorText = getString(R.string.error_user_collision);
                    } else {
                        errorText = exception.toString();
                    }
                    errorTV.setText(errorText);
                    errorTV.setVisibility(View.VISIBLE);
                }
                LoginManager.getInstance().logOut();
            }
        }
    });
}

private void logout(AuthData authData) {

        this.mAuthData = authData;

        if (this.mAuthData != null) {
            /* logout of Firebase */
            ref.unauth();
            /* Logout of any of the Frameworks. This step is optional, but ensures the user is not logged into
             * Facebook/Google+ after logging out of Firebase. */
            if (this.mAuthData.getProvider().equals("facebook")) {
                /* Logout from Facebook */
                LoginManager.getInstance().logOut();
            } else if (this.mAuthData.getProvider().equals("google")) {
                /* Logout from Google+ */
                if (mGoogleApiClient.isConnected()) {
                    Plus.AccountApi.clearDefaultAccount(mGoogleApiClient);
                    mGoogleApiClient.disconnect();
                }
            }
            /* Update authenticated user and show login buttons */
//            setAuthenticatedUser(null);
        }
    }

@Override
protected Void doInBackground(Void... arg0) {
    LoginManager.getInstance().logOut();

    SharedPref.removeAllPrefButGcm();
    App.clearUserVar();

    List<ActiveRideId> activeRideIds = ActiveRideId.listAll(ActiveRideId.class);
    if (!activeRideIds.isEmpty()) {
        for (ActiveRideId ari : activeRideIds) {
            FirebaseTopicsHandler.unsubscribeFirebaseTopic(ari.getRideId());
        }
    }

    Ride.deleteAll(Ride.class);
    RideRequestSent.deleteAll(RideRequestSent.class);
    ActiveRide.deleteAll(ActiveRide.class);
    RideRequestReceived.deleteAll(RideRequestReceived.class);
    ActiveRideId.deleteAll(ActiveRideId.class);
    ChatAssets.deleteAll(ChatAssets.class);

    return null;
}

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 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 onItemClick(int position) {
    ISocialType type = socialList.get(position);
    analytic.reportEvent(Analytic.Interaction.CLICK_SIGN_IN_SOCIAL, type.getIdentifier());
    if (type == SocialManager.SocialType.google) {
        if (client == null) {
            analytic.reportEvent(Analytic.Interaction.GOOGLE_SOCIAL_IS_NOT_ENABLED);
            Toast.makeText(App.Companion.getAppContext(), R.string.google_services_late, Toast.LENGTH_SHORT).show();
        } else {
            Intent signInIntent = Auth.GoogleSignInApi.getSignInIntent(client);
            activity.startActivityForResult(signInIntent, AppConstants.REQUEST_CODE_GOOGLE_SIGN_IN);
        }
    } else if (type == SocialManager.SocialType.facebook) {
        List<String> permissions = new ArrayList<>();
        permissions.add("email");
        LoginManager.getInstance().logInWithReadPermissions(activity, permissions);
    } else if (type == SocialManager.SocialType.vk) {
        String[] scopes = {VKScope.EMAIL};
        VKSdk.login(activity, scopes);
    } else {
        api.loginWithSocial(activity, type);
    }
}

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

    setText(root, R.id.ov_item_profile, R.string.profile_setting);
    setText(root, R.id.ov_item_notif, R.string.notif_setting);
    setText(root, R.id.ov_item_share, R.string.share);
    setText(root, R.id.ov_item_rate, R.string.rate);
    setText(root, R.id.ov_item_fb_like, R.string.like);
    setText(root, R.id.ov_item_feedback, R.string.feedback);
    setText(root, R.id.ov_item_about, R.string.about);
    setText(root, R.id.ov_item_rules, R.string.rules);
    setText(root, R.id.ov_item_contact, R.string.contact);
    setText(root, R.id.ov_item_sign_out, R.string.sign_out);

    setListener(root, R.id.ov_item_sign_out, new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            LoginManager.getInstance().logOut();
            new SessionManager(getActivity()).setLoggedIn(false);
            ((OnLogoutListener) getActivity()).onLogout();
        }
    });

    return root;
}

@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);
        }
    });
}

@Override
public void showError(String message) {

    Tracker t = ((AndroidApplication) getActivity().getApplication()).getTracker();
    t.send(new HitBuilders.EventBuilder()
            .setCategory(getString(R.string.ga_event_category_ux))
            .setAction(getString(R.string.ga_event_action_click))
            .setLabel(getString(R.string.ga_login_action_label_bad_userorpassword))
            .build());

    LoginManager.getInstance().logOut();
    new MaterialDialog.Builder(getActivity())
            .title(R.string.app_login_dlg_login_title)
            .content(message)
            .positiveText(R.string.accept)
            .show();
}

@Override
public void onClick(View v) {
    switch (v.getId()){
        case R.id.signInButton:
            signIn();
            break;

        case R.id.googleLoginButton:
            if(!googleApiClient.isConnecting()){
               googleButtonClicked = true;
                googleApiClient.connect();
            }
            break;
        case R.id.facebookLoginButton:
            if(AccessToken.getCurrentAccessToken()!=null){
                signInViaFacebook(AccessToken.getCurrentAccessToken());
            }else{
                LoginManager.getInstance().logInWithReadPermissions(this, Arrays.asList("public_profile"));
            }
            break;

        case R.id.twitterLoginButton:
            registerTwitterCallback();
            break;
    }
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    // Handle action bar item clicks here. The action bar will
    // automatically handle clicks on the Home/Up button, so long
    // as you specify a parent activity in AndroidManifest.xml.
    int id = item.getItemId();

    //noinspection SimplifiableIfStatement
    if (id == R.id.nav_logout) {
        LoginManager.getInstance().logOut();
        MMX.logout(null);
        Intent intent = new Intent(UserSelectActivity.this, LoginActivity.class);
        startActivity(intent);
        return true;
    }

    if (id == R.id.nav_refresh) {
        updateViewState();
        return true;
    }

    return super.onOptionsItemSelected(item);
}

public void askPublishPermissions(final LoginCallback cb) {
    if (AndroidNativeUtil.getActivity() == null) {
        throw new RuntimeException("Cannot ask for publish permissions when running in the background.");

    }
    if (loginLock) {
        return;
    }
    loginLock = true;

    LoginManager login = LoginManager.getInstance();
    final CallbackManager mCallbackManager = CallbackManager.Factory.create();
    final CodenameOneActivity activity = (CodenameOneActivity) AndroidNativeUtil.getActivity();
    activity.setIntentResultListener(new IntentResultListener() {

        @Override
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
            mCallbackManager.onActivityResult(requestCode, resultCode, data);
            activity.restoreIntentResultListener();
        }
    });
    login.registerCallback(mCallbackManager, new FBCallback(cb));
    login.logInWithPublishPermissions(activity, PUBLISH_PERMISSIONS);
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    FacebookSdk.sdkInitialize(getActivity());
    loginManager = LoginManager.getInstance();
    callbackManager = CallbackManager.Factory.create();
    mActivity = getActivity();
    mContext = getActivity().getApplicationContext();
    //Google
    mGoogleApiClient = new GoogleApiClient.Builder(mContext)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .addApi(Plus.API)
            .addScope(new Scope(Scopes.PROFILE))
            .build();
}