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