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);
            } 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,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,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));
    } 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,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,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(),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,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,0);
    } catch (SendIntentException e) {
        Log.w(TAG,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(),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,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,0);
        } catch (SendIntentException e) {
            Log.w(TAG,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,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,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,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(),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(),"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(),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,extraFlags);
}

@Override
public void startIntentSenderForMessageLoaderHelper(IntentSender si,int requestCode,int extraFlags) {
    showProgressthreshold = null;
    try {
        requestCode |= REQUEST_MASK_LOADER_HELPER;
        getActivity().startIntentSenderForResult(
                si,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(),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(),0);
    } catch (SendIntentException e) {
        e.printstacktrace();
    }
}