private void OnConnectionFailed(ConnectionResult result) { if (result.HasResolution) { result.StartResolutionForResult(_activity, ResolutionRequestCode); } }
public void OnConnectionFailed (ConnectionResult result) { Log.Debug (TAG, "onConnectionFailed:" + result); if (!mIsResolving && mShouldResolve) { if (result.HasResolution) { try { result.StartResolutionForResult (Activity, RC_SIGN_IN); mIsResolving = true; } catch (IntentSender.SendIntentException e) { Log.Error (TAG, "Could not resolve ConnectionResult.", e); mIsResolving = false; mGoogleApiClient.Connect (); } } else { ShowErrorDialog (result); } } else { UpdateUI (false); } }
public void OnConnectionFailed(ConnectionResult result) { Log.Debug(TAG, "onConnectionFailed:" + result); if (!mIsResolving && mShouldResolve) { if (result.HasResolution) { try { result.StartResolutionForResult(this, RC_SIGN_IN); mIsResolving = true; } catch (IntentSender.SendIntentException e) { Log.Error(TAG, "Could not resolve ConnectionResult.", e); mIsResolving = false; mGoogleApiClient.Connect(); } } else { ShowErrorDialog(result); } } else { UpdateUI(false); } }
public void OnConnectionFailed(ConnectionResult result) { if (resolvingError) { return; // Already attempting to resolve an error. } if (!(context is Activity)) { SimpleLocationLogger.Log("Connection failed. Error: " + result.ErrorCode); return; } if (result.HasResolution) { try { resolvingError = true; result.StartResolutionForResult(context as Activity, requestResolveError); } catch (Exception e) { SimpleLocationLogger.Log("Connection failed. Error: " + e.Message); googleApiClient.Connect(); // There was an error with the resolution intent. Try again. } } else { var dialog = GoogleApiAvailability.Instance.GetErrorDialog(context as Activity, result.ErrorCode, requestResolveError); dialog.DismissEvent += (sender, e) => resolvingError = false; dialog.Show(); resolvingError = true; } }
bool resolveConnectionFailure(Activity activity, Android.Gms.Common.Apis.GoogleApiClient client, ConnectionResult result, int requestCode, string fallbackErrorMessage) { 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. client.Connect(); return(false); } } else { // not resolvable... so show an error message int errorCode = result.ErrorCode; var dialog = GooglePlayServicesUtil.GetErrorDialog(errorCode, activity, requestCode); if (dialog != null) { dialog.Show(); } else { // no built-in dialog: show the fallback error message //ShowAlert (activity, fallbackErrorMessage); (new AlertDialog.Builder(activity)).SetMessage(fallbackErrorMessage) .SetNeutralButton(Android.Resource.String.Ok, delegate { }).Create().Show(); } return(false); } }
public void OnConnectionFailed(ConnectionResult result) { if (!mIsResolving & mShouldResolve) { if (result.HasResolution) { try { result.StartResolutionForResult(this, RC_SIGN_IN); mIsResolving = true; } catch (IntentSender.SendIntentException e) { mIsResolving = false; mGoogleApiClient.Connect(); } } else { ShowErrorDialog(result); } } else { UpdateData(false); } }
void resolveConnection() { if (mIsResolving) { return; } try { if (mConnectionResult != null && mConnectionResult.HasResolution) { mConnectionResult.StartResolutionForResult(Activity, REQUEST_CODE_RESOLVE_ERR); mIsResolving = true; } else { dismissProgressDialog(); } } catch (Android.Content.IntentSender.SendIntentException) { mConnectionResult = null; mIsResolving = false; dismissProgressDialog(); mGoogleApiClient.Connect(); } }
void ResolveConnectionResult() { // Try to resolve the problem //debugLog("resolveConnectionResult: trying to resolve result: " + mConnectionResult); if (connectionResult.HasResolution) { // This problem can be fixed. So let's try to fix it. //debugLog("result has resolution. Starting it."); try { // launch appropriate UI flow (which might, for example, be the // sign-in flow) expectingActivityResult = true; connectionResult.StartResolutionForResult(activity, RC_RESOLVE); } catch (Exception e) { // Try connecting again //debugLog("SendIntentException."); ConnectCurrentClient(); } } else { // It's not a problem what we can solve, so give up and show an // error. //debugLog("resolveConnectionResult: result has no resolution. Giving up."); GiveUp(); } }
public void OnConnectionFailed(ConnectionResult result) { if (Log.IsLoggable(Constants.TAG, LogPriority.Debug)) { Log.Debug(Constants.TAG, "Disconnected from Google Api Service"); } if (WearableClass.NodeApi != null) { WearableClass.NodeApi.RemoveListener(mGoogleApiClient, this); } if (mResolvingError) { // Already attempting to resolve the error return; } else if (result.HasResolution) { try { mResolvingError = true; result.StartResolutionForResult(this, REQUEST_RESOLVE_ERROR); } catch { // There was an error with the resolution intent. Try again mGoogleApiClient.Connect(); } } else { mResolvingError = false; } }
public void OnConnectionFailed(ConnectionResult result) { Log.Debug(TAG, "OnConnectionFailed"); if (_resolvingError) { return; } if (result.HasResolution) { try { _resolvingError = true; result.StartResolutionForResult(this, REQUEST_RESOLVE_ERROR); } catch (IntentSender.SendIntentException e) { Log.Debug(TAG, e.Message); client.Connect(); } } else { ShowErrorDialog(result.ErrorCode); } }
public void RequestGoogleFitnessAuthentication(ConnectionResult result) { if (!authInProgress) { authInProgress = true; result.StartResolutionForResult(this, REQUEST_GOOGLE_FITNESS_AUTH); } }
private void resolveGoogleLogin(ConnectionResult result) { if (result.HasResolution) { try { result.StartResolutionForResult(this, 9000); } catch (Android.Content.IntentSender.SendIntentException) { plusClient.Connect(); } } }
public void OnConnectionFailed(ConnectionResult result) { if (currentlyResolvingConnection) { return; } if (result.HasResolution) { currentlyResolvingConnection = true; result.StartResolutionForResult(activity, REQUEST_CODE_RESOLVE); } }
public void OnConnectionFailed(ConnectionResult result) { if (result.HasResolution) { try { result.StartResolutionForResult(this, 101); } catch (IntentSender.SendIntentException ex) { // Unable to resolve, message user appropriately } } else { GooglePlayServicesUtil.GetErrorDialog(result.ErrorCode, this, 0).Show(); } }
/// <summary> /// Checks to see if we have a resolution /// </summary> /// <param name="result">Result.</param> private void ResolveLogin(ConnectionResult result) { if (result.HasResolution) { try { result.StartResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR); } catch (Android.Content.IntentSender.SendIntentException e) { plusClient.Connect(); } } else if (progressDialog != null && progressDialog.IsShowing) { progressDialog.Dismiss(); } }
// // END IGoogleApiClientOnConnectionFailedListener private void ResolveConnectionResult(ConnectionResult result) { // Does this failure reason have a solution? if (result.HasResolution) { try { // Try to resolve the problem automatically. result.StartResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR); } catch (Android.Content.IntentSender.SendIntentException /*e*/) { mGoogleApiClient.Connect(); } } }
private void startResolution() { try { mLastConnectionResult.StartResolutionForResult(GetActivity(), mRequestCode); hideProgressDialog(); } catch (IntentSender.SendIntentException e) { // The intent we had is not valid right now, perhaps the remote process died. // Try to reconnect to get a new resolution intent. mLastConnectionResult = null; showProgressDialog(); connectPlusClient(); } }
//если ошибка подключения private void onConnectionFailed(ConnectionResult result) { if (!result.HasResolution) { GoogleApiAvailability.Instance.GetErrorDialog(this, result.ErrorCode, 0).Show(); return; } try { result.StartResolutionForResult(this, REQUEST_CODE_RESOLUTION); } catch (IntentSender.SendIntentException e) { CreateAlertDialog("", errorMessage + e.Message); } }
public void OnConnectionFailed(ConnectionResult result) { mMomentListView.Adapter = null; if (mResolvingError) { return; } try { result.StartResolutionForResult(this, REQUEST_CODE_SIGN_IN); mResolvingError = true; } catch (IntentSender.SendIntentException e) { // Try connecting again. mGoogleApiClient.Connect(); } }
public void OnConnectionFailed(ConnectionResult result) { if (mResolvingError) { return; } mPersonListView.Adapter = null; try { result.StartResolutionForResult(this, REQUEST_CODE_SIGN_IN); mResolvingError = true; } catch (Android.Content.IntentSender.SendIntentException) { // Get another pending intent to run. mGoogleApiClient.Connect(); } }
void resolveConnection() { try { if (mConnectionResult != null && mConnectionResult.HasResolution) { mConnectionResult.StartResolutionForResult(Activity, REQUEST_CODE_RESOLVE_ERR); } else { mGoogleApiClient.Connect(); } } catch (Android.Content.IntentSender.SendIntentException e) { mConnectionResult = null; mGoogleApiClient.Connect(); } }
void resolveSignInError() { if (mConnectionResult.HasResolution) { try { mIntentInProgress = true; logVerbose("Start the resolution intent, flipping the intent-in-progress bit."); mConnectionResult.StartResolutionForResult(this, REQUEST_CODE_SIGN_IN); } 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. mIntentInProgress = false; mGoogleApiClient.Connect(); Console.WriteLine("Error sending the resolution Intent, connect() again."); } } }
public void OnConnectionFailed(ConnectionResult result) { if (resolvingError) return; // Already attempting to resolve an error. if (result.HasResolution) try { resolvingError = true; result.StartResolutionForResult(context, 1001); } catch (Exception e) { Console.WriteLine("[SimpleLocation: Connection failed. Error: {0}]", e.Message); googleApiClient.Connect(); // There was an error with the resolution intent. Try again. } else { GooglePlayServicesUtil.GetErrorDialog(result.ErrorCode, context, 9000)?.Show(); resolvingError = true; } }
public void OnConnectionFailed(ConnectionResult result) { if (result.HasResolution) { try { result.StartResolutionForResult((Activity)context, RequestCode_RESOLUTION); } catch (IntentSender.SendIntentException e) { Console.WriteLine("Failed to start resolution result: " + e.Message); } } else { Console.WriteLine("Failed without resolution"); } }
public void OnConnectionFailed(ConnectionResult result) { if (resolving) { return; } if (result.HasResolution) { resolving = true; result.StartResolutionForResult(activity, RC_RESOLVE); return; } resolving = false; SignedOut = false; signingIn = false; OnSignInFailed?.Invoke(this, EventArgs.Empty); }
public void OnConnectionFailed(ConnectionResult result) { Debug.WriteLine("Google API connection failed!"); if (result.HasResolution) { try { Debug.WriteLine("Google API start asking"); result.StartResolutionForResult(MainActivity.Current, RESULT_CODE); } catch (IntentSender.SendIntentException e) { // Unable to resolve, message user appropriately } } else { GooglePlayServicesUtil.ShowErrorDialogFragment(result.ErrorCode, MainActivity.Current, 0); } }
protected void onConnectionFailed(ConnectionResult result) { // Called whenever the API client fails to connect. Log.Info(TAG, "GoogleApiClient connection failed: " + result); if (!result.HasResolution) { // show the localized error dialog. GoogleApiAvailability.Instance.GetErrorDialog(this, result.ErrorCode, 0).Show(); return; } // The failure has a resolution. Resolve it. // Called typically when the app is not yet authorized, and an authorization dialog is displayed to the user. try { result.StartResolutionForResult(this, REQUEST_CODE_RESOLUTION); } catch (IntentSender.SendIntentException e) { Log.Error(TAG, "Exception while starting resolution activity", e); } }
IObservable<bool> IConnectionResultHandler.HandleConnectionResult(ConnectionResult connectionResult) { if (!connectionResult.HasResolution) { GoogleApiAvailability .Instance .GetErrorDialog(this, connectionResult.ErrorCode, 0) .Show(); return Observable.Return(false); } try { this.resultResolutionSubject.Disposable = new Subject<bool>(); connectionResult.StartResolutionForResult(this, RequestCodeResolution); return this.resultResolutionSubject.Disposable; } catch (IntentSender.SendIntentException) { return Observable.Return(false); } }
IObservable <bool> IConnectionResultHandler.HandleConnectionResult(ConnectionResult connectionResult) { if (!connectionResult.HasResolution) { GoogleApiAvailability .Instance .GetErrorDialog(this, connectionResult.ErrorCode, 0) .Show(); return(Observable.Return(false)); } try { this.resultResolutionSubject.Disposable = new Subject <bool>(); connectionResult.StartResolutionForResult(this, RequestCodeResolution); return(this.resultResolutionSubject.Disposable); } catch (IntentSender.SendIntentException) { return(Observable.Return(false)); } }
public void OnConnectionFailed(ConnectionResult result) { if (_resolving) { return; } if (result.HasResolution) { _resolving = true; result.StartResolutionForResult(AppMain.Activity, RcResolve); return; } GamerPlatformSettings.Instance.ShouldBeSignedIn = true; GamerPlatformSettings.Instance.Serialize(); _resolving = false; _signingIn = false; OnSignInFailed(GamerError.ErrorSignIn); }
public void OnConnectionFailed(ConnectionResult result) { if (resolving) { return; } if (result.HasResolution) { resolving = true; result.StartResolutionForResult(activity, RC_RESOLVE); this.adapter.OnActivityResult += this.OnConnectionFailedActivityResult; return; } resolving = false; SignedOut = false; signingin = false; if (this.OnSignInFailed != null) { this.OnSignInFailed(this, EventArgs.Empty); } }
public void OnConnectionFailed(ConnectionResult result) { if (!mIsResolving && mShouldResolve) { if (result.HasResolution) { try { result.StartResolutionForResult(this, RC_SIGN_IN); mIsResolving = true; } catch { mIsResolving = false; mGoogleApiClient.Connect(); } } } else { UpdateUI(false); } }
public void OnConnectionFailed(ConnectionResult result) { Log.Error(TAG, "Connect to Google API failed: {0}.", result.ErrorCode); if (_authInProgress) { return; } if (!result.HasResolution) { return; } try { _authInProgress = true; result.StartResolutionForResult(this, GOOGLE_PLAY_SERVICES_REQUEST_AUTHORIZATION); } catch (IntentSender.SendIntentException e) { _authInProgress = false; Log.Error(TAG, "Could not resolve Google Play Services error: {0}", e.LocalizedMessage); } }
/** * Resolve a connection failure from * {@link com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener#onConnectionFailed(com.google.android.gms.common.ConnectionResult)} * * @param activity the Activity trying to resolve the connection failure. * @param client the GoogleAPIClient instance of the Activity. * @param result the ConnectionResult received by the Activity. * @param requestCode a request code which the calling Activity can use to identify the result * of this resolution in onActivityResult. * @param fallbackErrorMessage a generic error message to display if the failure cannot be resolved. * @return true if the connection failure is resolved, false otherwise. */ public static bool ResolveConnectionFailure(Activity activity, GoogleApiClient client, ConnectionResult result, int requestCode, string fallbackErrorMessage) { 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. client.Connect(); return(false); } } else { // not resolvable... so show an error message int errorCode = result.ErrorCode; Dialog dialog = GooglePlayServicesUtil.GetErrorDialog(errorCode, activity, requestCode); if (dialog != null) { dialog.Show(); } else { // no built-in dialog: show the fallback error message ShowAlert(activity, fallbackErrorMessage); } return(false); } }
public void OnConnectionFailed (ConnectionResult result) { if (mResolvingError) return; mPersonListView.Adapter = null; try { result.StartResolutionForResult (this, REQUEST_CODE_SIGN_IN); mResolvingError = true; } catch (Android.Content.IntentSender.SendIntentException) { // Get another pending intent to run. mGoogleApiClient.Connect (); } }
/// <summary> /// After we fail to connect to Google Play, it will tell us why. In some cases the /// failure reason can be automatically resolved (eg. Login Required). /// </summary> /// <param name="result">The reason we failed to connect.</param> private void ResolveLogin(ConnectionResult result) { // Does this failure reason have a solution? if (result.HasResolution) { try { // Try to resolve the problem automatically. result.StartResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR); } catch (Android.Content.IntentSender.SendIntentException /*e*/) { // Not really sure why this is here. pGooglePlayClient.Connect(); } } }
/// <summary> /// Called when [connection failed]. /// </summary> /// <param name="result">The result.</param> public void OnConnectionFailed(ConnectionResult result) { if (this.resolving) { return; } if (result.HasResolution) { this.resolving = true; result.StartResolutionForResult(this.activity, RC_RESOLVE); this.adapter.OnActivityResult += this.OnConnectionFailedActivityResult; return; } this.resolving = false; this.SignedOut = false; this.signingin = false; if (this.OnSignInFailed != null) { this.OnSignInFailed(this, EventArgs.Empty); } }
public void OnConnectionFailed(ConnectionResult result) { _connectStopwatch.Stop(); Logger.Warn($"{_activity.GetType()} Google Play Services connection failed after {_connectStopwatch.ElapsedMilliseconds}ms: {result}"); if(IsResolvingError) { return; } if(!result.HasResolution) { Logger.Debug($"{_activity.GetType()} Google Play Services connection failure has no resolution, showing error dialog..."); // TODO: if the error here is service missing, bad things happen (as per the emulator behavior) IsResolvingError = true; GoogleApiAvailability.Instance.GetErrorDialog(_activity, result.ErrorCode, 0).Show(); IsResolvingError = false; OnConnected(new PlayServicesConnectedEventArgs { IsSuccess = false }); return; } try { IsResolvingError = true; Logger.Debug($"{_activity.GetType()} Starting Google Play Services connection failure resolution activity..."); result.StartResolutionForResult(_activity, RequestCodeResolveError); } catch(IntentSender.SendIntentException) { Logger.Error($"{_activity.GetType()} Exception while starting resolution activity, retrying connection..."); ConnectAsync().Wait(); } }
public void OnConnectionFailed (ConnectionResult result) { if (Log.IsLoggable(Constants.TAG, LogPriority.Debug)) { Log.Debug (Constants.TAG, "Disconnected from Google Api Service"); } if (WearableClass.NodeApi != null) { WearableClass.NodeApi.RemoveListener (mGoogleApiClient, this); } if (mResolvingError) { // Already attempting to resolve the error return; } else if (result.HasResolution) { try { mResolvingError = true; result.StartResolutionForResult (this, REQUEST_RESOLVE_ERROR); } catch { // There was an error with the resolution intent. Try again mGoogleApiClient.Connect (); } } else { mResolvingError = false; } }
/// <summary> /// Checks to see if we have a resolution /// </summary> /// <param name="result">Result.</param> private void ResolveLogin(ConnectionResult result) { if (result.HasResolution) { try { result.StartResolutionForResult (this, REQUEST_CODE_RESOLVE_ERR); } catch (Android.Content.IntentSender.SendIntentException e) { plusClient.Connect (); } } else if(progressDialog != null && progressDialog.IsShowing) { progressDialog.Dismiss (); } }
public void OnConnectionFailed (ConnectionResult result) { if (resolving) return; if (result.HasResolution) { resolving = true; result.StartResolutionForResult (activity, RC_RESOLVE); return; } resolving = false; SignedOut = false; signingin = false; if (OnSignInFailed != null) OnSignInFailed (this, EventArgs.Empty); }