Java 类android.content.IntentSender.SendIntentException 实例源码

private void handleSignInResult(GoogleSignInResult m_result) {
    if (m_result.isSuccess()) {
        mAccount = m_result.getSignInAccount();
        succeedSignIn();
    } else {
        Status s = m_result.getStatus();

        Log.w(TAG, "SignInResult::Failed code="
        + s.getStatusCode() + ", Message: " + s.getStatusMessage());

        if (isResolvingConnectionFailure) { return; }
        if (!isIntentInProgress && m_result.getStatus().hasResolution()) {
            try {
                isIntentInProgress = true;

                activity.startIntentSenderForResult(
                s.getResolution().getIntentSender(),
                GOOGLE_SIGN_IN_REQUEST, null, 0, 0, 0);
            } catch (SendIntentException ex) {
                connect();
            }

            isResolvingConnectionFailure = true;
        }
    }
}

@Override
public void onConnectionFailed(@NonNull ConnectionResult m_result) {
    Utils.d("Google:Connection:Failed");

    if (isResolvingConnectionFailure) { return; }
    if(!isIntentInProgress && m_result.hasResolution()) {
        try {
            isIntentInProgress = true;

            activity.startIntentSenderForResult(
            m_result.getResolution().getIntentSender(),
            Utils.FIREBASE_GOOGLE_SIGN_IN, null, 0, 0, 0);

        } catch (SendIntentException ex) {
            isIntentInProgress = false;
            signIn();
        }

        isResolvingConnectionFailure = true;
        Utils.d("Google:Connection:Resolving.");
               }
}

public boolean resolveConnectionFailure(ConnectionResult result, int requestCode) {
    if (result.hasResolution()) {
        try {
            result.startResolutionForResult(activity, requestCode);
            return true;
        } catch (IntentSender.SendIntentException e) {
            // The intent was canceled before it was sent.  Return to the default
            // state and attempt to connect to get an updated ConnectionResult.
            googleApiClient.connect();
            return false;
        }
    } else {
        // not resolvable... so show an error message
        int errorCode = result.getErrorCode();

        if (errorCode == ConnectionResult.INTERNAL_ERROR) {
            googleApiClient.connect();
        }

        GodotLib.calldeferred(instance_id, "_on_google_play_game_services_connection_failed", new Object[] { });
        Log.i(TAG, "GPGS: onConnectionFailed error code: " + String.valueOf(errorCode));
        return false;
    }
}

public final void run()
{
  if (this.b.a()) {
    try
    {
      int i = 1 + (1 + this.c.f().b.a.d.f().indexOf(this.c) << 16);
      this.b.a(this.c.f(), i);
      return;
    }
    catch (IntentSender.SendIntentException localSendIntentException)
    {
      ehe.a(this.c);
      return;
    }
  }
  if (eer.b(this.b.c))
  {
    eer.a(this.b.c, this.c.f(), this.c, 2, this.c);
    return;
  }
  ehe.a(this.c, this.a, this.b);
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    if (commonProgressDialog.isShowing()) {
        // The user clicked the sign-in button already. Start to resolve
        // connection errors. Wait until onConnected() to dismiss the
        // connection dialog.
        if (result.hasResolution()) {
            try {
                result.startResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR);
            } catch (SendIntentException e) {
                Log.e(TAG, e.getMessage(), e);
                // Yeah, no idea what to do here.
                commonProgressDialog.dismiss();
                Toast.makeText(LoginActivity.this, R.string.google_app_login_failed, Toast.LENGTH_SHORT).show();
            }
        } else {
            commonProgressDialog.dismiss();
            if (!isNetworkAvailable()) {
                Toast.makeText(LoginActivity.this, R.string.toast_no_internet_connection, Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(LoginActivity.this, R.string.google_app_login_failed, Toast.LENGTH_SHORT).show();
            }

        }
    }
}

/**
 * A helper method to flip the mResolveOnFail flag and start the resolution
 * of the ConnenctionResult from the failed connect() call.
 */
private void startResolution() {

    try {
        // Don't start another resolution now until we have a
        // result from the activity we're about to start.
        mResolveOnFail = false;
        // If we can resolve the error, then call start resolution
        // and pass it an integer tag we can use to track. This means
        // that when we get the onActivityResult callback we'll know
        // its from being started here.
        mConnectionResult
                        .startResolutionForResult(mActivity, CONNECTION_UPDATE_ERROR);
    } catch (final SendIntentException e) {
        // Any problems, just try to connect() again so we get a new
        // ConnectionResult.
        mPlusClient.connect();
    }
}

public void purchaseIntent(String sku, int REQUEST_CODE) {
    if (mService == null) return;
    try {
        String developerPayload = "abcdefghijklmnopqrstuvwxyz";
        Bundle buyIntentBundle = mService.getBuyIntent(3, getPackageName(),
                sku, "inapp",developerPayload);
        PendingIntent pendingIntent = buyIntentBundle.getParcelable("BUY_INTENT");
        startIntentSenderForResult(pendingIntent.getIntentSender(),
                REQUEST_CODE, new Intent(), Integer.valueOf(0), Integer.valueOf(0),
                Integer.valueOf(0));
    } catch (RemoteException e1) {
        return;
    } catch (SendIntentException e2) {
        return;
    }
}

@Override
public int showCancelableIntent(
        PendingIntent intent, IntentCallback callback, Integer errorId) {
    Activity activity = getActivity().get();
    if (activity == null) return START_INTENT_FAILURE;

    int requestCode = generateNextRequestCode();

    try {
        activity.startIntentSenderForResult(
                intent.getIntentSender(), requestCode, new Intent(), 0, 0, 0);
    } catch (SendIntentException e) {
        return START_INTENT_FAILURE;
    }

    storeCallbackData(requestCode, callback, errorId);
    return requestCode;
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    if (!mIntentInProgress && result.hasResolution()) {
        try {
            mIntentInProgress = true;
            startIntentSenderForResult(result.getResolution()
                    .getIntentSender(), RC_SIGN_IN, null, 0, 0, 0);
        } catch (SendIntentException e) {
            // The intent was canceled before it was sent. Return to the
            // default
            // state and attempt to connect to get an updated
            // ConnectionResult.
            mIntentInProgress = false;
            mGoogleApiClient.connect();
        }
    }
}

@Override
public void onResult(LocationSettingsResult locationSettingsResult) {
    final Status status = locationSettingsResult.getStatus();
    switch (status.getStatusCode()) {
        case LocationSettingsStatusCodes.SUCCESS:
            Log.i(TAG, "All location settings are satisfied.");
            GetLastLocation();
            break;
        case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
            Log.i(TAG, "Location settings are not satisfied. Show the user a dialog to" +
                    "upgrade location settings ");

            try {
                // Show the dialog by calling startResolutionForResult(), and check the result
                // in onActivityResult().
                status.startResolutionForResult(mActivity, REQUEST_CHECK_SETTINGS);
            } catch (IntentSender.SendIntentException e) {                   
                ErrorHappened("PendingIntent unable to execute request.");
            }
            break;
        case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:              
            ErrorHappened("Location settings are inadequate, and cannot be fixed here. Dialog " +
                    "not created.");
            break;
    }
}

private void resolveSignInError() {
    if (connectionResult.hasResolution()) {
        try {
            intentInProgress = true;
            startIntentSenderForResult(connectionResult.getResolution()
                    .getIntentSender(), RC_SIGN_IN, null, 0, 0, 0);
        } catch (SendIntentException e) {
            Log.i(LOG_TAG,
                    "Sign in intent could not be sent: "
                            + e.getLocalizedMessage());
            // The intent was canceled before it was sent. Return to the
            // default
            // state and attempt to connect to get an updated
            // ConnectionResult.
            intentInProgress = false;
            googleAPIClient.connect();
        }
    }
}

public void onConnectionFailed(ConnectionResult paramConnectionResult)
{
  if (paramConnectionResult.hasResolution())
    try
    {
      ˎ localˎ = getActivity();
      getActivity();
      paramConnectionResult.startResolutionForResult(localˎ, 9000);
      return;
    }
    catch (IntentSender.SendIntentException localSendIntentException)
    {
      this.mGoogleApiClient.connect();
      localSendIntentException.printStackTrace();
    }
}

public void onConnectionFailed(ConnectionResult paramConnectionResult)
{
  if (this.activity == null)
    return;
  if (paramConnectionResult.hasResolution())
    try
    {
      paramConnectionResult.startResolutionForResult(this.activity, 9000);
      return;
    }
    catch (IntentSender.SendIntentException localSendIntentException)
    {
      localSendIntentException.printStackTrace();
      return;
    }
  paramConnectionResult.getErrorCode();
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    if (mResolvingError) {
           // Already attempting to resolve an error.
           return;
       } else if (result.hasResolution()) {
           try {
               mResolvingError = true;
               result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
           } catch (SendIntentException e) {
               // There was an error with the resolution intent. Try again.
               mGoogleApiClient.connect();
           }
       } else {
           // Show dialog using GooglePlayServicesUtil.getErrorDialog()
           showErrorDialog(result.getErrorCode());
           mResolvingError = true;
       }

}

@Override
public void onConnected(Bundle connectionHint) {
    super.onConnected(connectionHint);

    // If there is a selected file, open its contents.
    if (mSelectedFileDriveId != null) {
        open();
        return;
    }

    // Let the user pick an mp4 or a jpeg file if there are
    // no files selected by the user.
    IntentSender intentSender = Drive.DriveApi
            .newOpenFileActivityBuilder()
            .setMimeType(new String[]{ "video/mp4", "image/jpeg" })
            .build(getGoogleApiClient());
    try {
        startIntentSenderForResult(intentSender, REQUEST_CODE_OPENER, null, 0, 0, 0);
    } catch (SendIntentException e) {
      Log.w(TAG, "Unable to send intent", e);
    }
}

@Override
public void onResult(ContentsResult result) {
    MetadataChangeSet metadataChangeSet = new MetadataChangeSet.Builder()
            .setMimeType("text/html").build();
    IntentSender intentSender = Drive.DriveApi
            .newCreateFileActivityBuilder()
            .setInitialMetadata(metadataChangeSet)
            .setInitialContents(result.getContents())
            .build(getGoogleApiClient());
    try {
        startIntentSenderForResult(
                intentSender, REQUEST_CODE_CREATOR, null, 0, 0, 0);
    } catch (SendIntentException e) {
        Log.w(TAG, "Unable to send intent", e);
    }
}

private void handleConnectionResult(ConnectionResult result) {
    if (result.hasResolution()) {
        try {
            result.startResolutionForResult(activity,
                    REQUEST_START_RESOLUTION_FOR_RESULT);
        } catch (SendIntentException e) {
            Log.e(this.getClass().getSimpleName(),
                    "unexpected exception for startResolutionForResult", e);
        }
        return;
    }
    listener.onError(result);
    Dialog errorDialog = GooglePlayServicesUtil.getErrorDialog(
            result.getErrorCode(), activity, REQUEST_GET_ERROR_DIALOG);
    if (errorDialog != null) {
        errorDialog.show();
    }

}

public void resolveSignInError() {
    if (mSignInIntent != null) {
        try {
            mSignInProgress = STATE_IN_PROGRESS;
            ubiNomadActivity.startIntentSenderForResult(mSignInIntent.getIntentSender(),
                    RC_SIGN_IN, null, 0, 0, 0);
        } catch (SendIntentException e) {
            Log.i(TAG, "Sign in intent could not be sent: "
                    + e.getLocalizedMessage());
            // The intent was canceled before it was sent.  Attempt to connect to
            // get an updated ConnectionResult.
            mSignInProgress = STATE_SIGN_IN;
            mGoogleApiClient.connect();
        }
    } else {
        // Google Play services wasn't able to provide an intent for some
        // error types, so we show the default Google Play services error
        // dialog which may still start an intent on our behalf if the
        // user can resolve the issue.
        DialogFragment dialog = new GoogleSignInDialog();
        Bundle args = new Bundle();
        args.putInt("id", DIALOG_PLAY_SERVICES_ERROR);
        dialog.setArguments(args);
        dialog.show(ubiNomadActivity.getSupportFragmentManager(), "tag");
    }  
}

/**
 * A helper method to flip the mResolveOnFail flag and start the resolution
 * of the ConnenctionResult from the failed connect() call.
 */
private void startResolution() {

    try {
        // Don't start another resolution now until we have a
        // result from the activity we're about to start.
        mResolveOnFail = false;
        // If we can resolve the error, then call start resolution
        // and pass it an integer tag we can use to track. This means
        // that when we get the onActivityResult callback we'll know
        // its from being started here.
        mConnectionResult
                        .startResolutionForResult(mActivity, CONNECTION_UPDATE_ERROR);
    } catch (final SendIntentException e) {
        // Any problems, just try to connect() again so we get a new
        // ConnectionResult.
        mPlusClient.connect();
    }
}

/**
 * Starts a file opener intent to pick a file.
 */
@Override
public void onConnected(Bundle connectionHint) {
    super.onConnected(connectionHint);
    if (mFileId == null) {
        IntentSender intentSender = Drive.DriveApi
                .newOpenFileActivityBuilder()
                .setMimeType(new String[] {"application/octet-stream"})
                .build(getGoogleApiClient());
        try {
            startIntentSenderForResult(intentSender, REQUEST_CODE_OPENER,
                    null, 0, 0, 0);
        } catch (SendIntentException e) {
            Log.w(TAG, "Unable to send intent", e);
        }
    } else {
        DriveFile file = Drive.DriveApi.getFile(getGoogleApiClient(), mFileId);
        file.getMetadata(getGoogleApiClient()).setResultCallback(metadataCallback);
    }
}

@Override
public void onConnected(Bundle connectionHint) {
    super.onConnected(connectionHint);

    // If there is a selected file, open its contents.
    if (mSelectedFileDriveId != null) {
        open();
        return;
    }

    // Let the user pick an mp4 or a jpeg file if there are
    // no files selected by the user.
    IntentSender intentSender = Drive.DriveApi
            .newOpenFileActivityBuilder()
            .setMimeType(new String[]{ "video/mp4", "image/jpeg" })
            .build(getGoogleApiClient());
    try {
        startIntentSenderForResult(intentSender, REQUEST_CODE_OPENER, null, 0, 0, 0);
    } catch (SendIntentException e) {
      Log.w(TAG, "Unable to send intent", e);
    }
}

@Override
public void onResult(ContentsResult result) {
    MetadataChangeSet metadataChangeSet = new MetadataChangeSet.Builder()
            .setMimeType("text/html").build();
    IntentSender intentSender = Drive.DriveApi
            .newCreateFileActivityBuilder()
            .setInitialMetadata(metadataChangeSet)
            .setInitialContents(result.getContents())
            .build(getGoogleApiClient());
    try {
        startIntentSenderForResult(
                intentSender, REQUEST_CODE_CREATOR, null, 0, 0, 0);
    } catch (SendIntentException e) {
        Log.w(TAG, "Unable to send intent", e);
    }
}

/**
 * Forces user to pick a file on connection.
 */
@Override
public void onConnected(Bundle connectionHint) {
    if (mSelectedFileId == null) {
        IntentSender intentSender = Drive.DriveApi
                .newOpenFileActivityBuilder()
                .setMimeType(new String[] { "text/plain" })
                .build(getGoogleApiClient());
        try {
            startIntentSenderForResult(intentSender, REQUEST_CODE_OPENER,
                    null, 0, 0, 0);
        } catch (SendIntentException e) {
            Log.w(TAG, "Unable to send intent", e);
        }
    }
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    Log.i(TAG, "Connection failed: " + result.getErrorCode());
    if (!result.hasResolution()) {
        GooglePlayServicesUtil.showErrorDialogFragment(result.getErrorCode(), this, 0);
        return;
    }
    // If user interaction is required to resolve the connection failure, the result will
    // contain a resolution.  This will launch a UI that allows the user to resolve the issue.
    // (E.g., authorize your app.)
    try {
        result.startResolutionForResult(this, RESOLVE_CONNECTION_REQUEST_CODE);
    } catch (SendIntentException e) {
        Log.i(TAG, "Send intent failed", e);
    }
}

/**
 * Called when {@code mGoogleApiClient} is trying to connect but failed.
 * Handle {@code result.getResolution()} if there is a resolution is
 * available.
 */
@Override
public void onConnectionFailed(ConnectionResult result) {
    Log.i(TAG, "GoogleApiClient connection failed: " + result.toString());
    if (!result.hasResolution()) {
        // show the localized error dialog.
        GooglePlayServicesUtil.getErrorDialog(result.getErrorCode(), this,
                0).show();
        return;
    }
    try {
        result.startResolutionForResult(this, REQUEST_CODE_RESOLUTION);
    } catch (SendIntentException e) {
        Log.e(TAG, "Exception while starting resolution activity", e);
    }
}

@Override public void onConnectionFailed (ConnectionResult result) {
 String errormessage = result.toString();
 Log.w (LOG_TAG, errormessage);
 connectionAttempts += 1;
 if (!result.hasResolution() || connectionAttempts >= 2) {
  Log.w (LOG_TAG, "Error: no resolution. Google Play Services connection failed.");
  tryConnectCallback.error ("Error: " + errormessage + "."); tryConnectCallback = null;
  return;
 }
 try {
  result.startResolutionForResult (cordova.getActivity(), result.getErrorCode());
 } catch (SendIntentException e) {
  // There was an error with the resolution intent. Try again.
  mGoogleApiClient.connect ();
 }
}

private void resolveSignInError() {
    if (connectionResult.hasResolution()) {
        try {
            intentInProgress = true;
            startIntentSenderForResult(connectionResult.getResolution()
                    .getIntentSender(), RC_SIGN_IN, null, 0, 0, 0);
        } catch (SendIntentException e) {
            Log.i(LOG_TAG,
                    "Sign in intent could not be sent: "
                            + e.getLocalizedMessage());
            // The intent was canceled before it was sent. Return to the
            // default
            // state and attempt to connect to get an updated
            // ConnectionResult.
            intentInProgress = false;
            googleAPIClient.connect();
        }
    }
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    if (this.resolvingError) {
        return;
    }
    if (result.hasResolution()) {
        try {
            this.resolvingError = true;
            result.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
        } catch (SendIntentException sie) {
            MTLog.w(this, sie, "Error while resolving Google Play Services error!");
            GoogleApiClient googleApiClient = getGoogleApiClientOrInit();
            if (googleApiClient != null) {
                googleApiClient.connect();
            }
        }
    } else {
        showErrorDialog(result.getErrorCode());
        this.resolvingError = true;
    }
}

@Override
public void onConnectionFailed(ConnectionResult result)
{
    if ((!this.intentInProgress) && result.hasResolution())
    {
        try
        {
            this.intentInProgress = true;
            result.startResolutionForResult(this, MainActivity.REQUEST_RESOLVE_ERROR);
        }
        catch (SendIntentException e)
        {
            this.intentInProgress = false;
            this.apiClient.connect();
        }
    }
}

@Override
public void onConnectionFailed(ConnectionStatus status) {
  int errorCode = status.getErrorCode();
  if (status.hasResolution()) {
    try {
      // This usually happen when user needs to authenticate into Games API.
      status.startResolutionForResult(this, REQUEST_CODE_RECONNECT);
    } catch (SendIntentException e) {
      Log.e(TAG, "Unable to recover from a connection failure: " + errorCode + ".");
      this.finish();
    }
  } else {
    Log.e(TAG, "Did you install GmsCore.apk?");
    this.finish();
  }
}

private void resolveSignInError()
{
    if (mConnectionResult.hasResolution())
    {
        try
        {
            mIntentInProgress = true;
            startIntentSenderForResult(mConnectionResult.getResolution().getIntentSender(), RC_SIGN_IN, null, 0, 0, 0);
        }
        catch (SendIntentException e)
        {
            // The intent was canceled before it was sent. Return to the
            // default
            // state and attempt to connect to get an updated
            // ConnectionResult.
            mIntentInProgress = false;
            mGoogleApiClient.connect();
        }
    }
}

@Override
public void onClick(View view) {
    if (view.getId() == R.id.sign_in_button && !mPlusClient.isConnected()) {
        if (mConnectionResult == null) {
            mConnectionProgressDialog.show();
        } else {
            try {
                mConnectionResult.startResolutionForResult(LoginActivity.this, CONNECTION_FAILURE_RESOLUTION_REQUEST);
            } catch (SendIntentException e) {
                // Try connecting again.
                mConnectionResult = null;
                mPlusClient.connect();
            }
        }
    }
}

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
    if (mConnectionProgressDialog.isShowing()) {
        // The user clicked the sign-in button already. Start to resolve
        // connection errors. Wait until onConnected() to dismiss the
        // connection dialog.
        if (connectionResult.hasResolution()) {
          try {
                   connectionResult.startResolutionForResult(this, CONNECTION_FAILURE_RESOLUTION_REQUEST);
           } catch (SendIntentException e) {
                   mPlusClient.connect();
           }
        }
      }
      // Save the result and resolve the connection failure upon a user click.
      mConnectionResult = connectionResult;
}

@Override
public void onClick(View view) {
    if (view.getId() == R.id.sign_in_button && !mPlusClient.isConnected()) {
        if (mConnectionResult == null) {
            mPlusClient.connect();
            mProgress.setVisibility(View.VISIBLE);

        } else {
            try {
                mConnectionResult.startResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR);
            } catch (SendIntentException e) {
                // Try connecting again.
                e.printStackTrace();
                mConnectionResult = null;
                connectGPlus();
            }
        }
    }
}

@Override
public void onConnectionFailed(ConnectionResult result) {
    if (mProgress.getVisibility() == View.VISIBLE) {
        // The user clicked the sign-in button already. Start to resolve
        // connection errors. Wait until onConnected() to dismiss the
        // connection dialog.
        if (result.hasResolution()) {
            try {
                result.startResolutionForResult(this,
                        REQUEST_CODE_RESOLVE_ERR);
            } catch (SendIntentException e) {
                e.printStackTrace();
                connectGPlus();
            }
        }
    }
    // Save the result and resolve the connection failure upon a user click.
    mConnectionResult = result;
}

@Override
public void onConnectionFailed(ConnectionResult res) {
    if (mConnectionProgressDialog.isShowing()) {

        if (res.hasResolution()) {
            try {
                res.startResolutionForResult(this.getActivity(), REQUEST_CODE_RESOLVE_ERR);
            } catch (SendIntentException e) {
                mPlusClient.connect();
            }
        }
    }

    // Save the intent so that we can start an activity when the user clicks
    // the sign-in button.
    mConnectionResult = res;
}

@Override
public void startPendingIntentForCryptoPresenter(IntentSender si, Integer requestCode, Intent fillIntent,
        int flagsMask, int flagValues, int extraFlags) throws SendIntentException {
    if (requestCode == null) {
        getActivity().startIntentSender(si, fillIntent, flagsMask, flagValues, extraFlags);
        return;
    }

    requestCode |= REQUEST_MASK_CRYPTO_PRESENTER;
    getActivity().startIntentSenderForResult(
            si, requestCode, fillIntent, flagsMask, flagValues, extraFlags);
}

@Override
public void startIntentSenderForMessageLoaderHelper(IntentSender si, int requestCode, Intent fillIntent,
        int flagsMask, int flagValues, int extraFlags) {
    showProgressThreshold = null;
    try {
        requestCode |= REQUEST_MASK_LOADER_HELPER;
        getActivity().startIntentSenderForResult(
                si, requestCode, fillIntent, flagsMask, flagValues, extraFlags);
    } catch (SendIntentException e) {
        Timber.e(e, "Irrecoverable error calling PendingIntent!");
    }
}

@Override
public void onMessageBuildReturnPendingIntent(PendingIntent pendingIntent, int requestCode) {
    requestCode |= REQUEST_MASK_MESSAGE_BUILDER;
    try {
        startIntentSenderForResult(pendingIntent.getIntentSender(), requestCode, null, 0, 0, 0);
    } catch (SendIntentException e) {
        Timber.e(e, "Error starting pending intent from builder!");
    }
}

public void launchUserInteractionPendingIntent(PendingIntent pendingIntent, int requestCode) {
    requestCode |= REQUEST_MASK_RECIPIENT_PRESENTER;
    try {
        startIntentSenderForResult(pendingIntent.getIntentSender(), requestCode, null, 0, 0, 0);
    } catch (SendIntentException e) {
        e.printStackTrace();
    }
}