Java 类com.google.android.gms.common.GooglePlayServicesUtil 实例源码

private boolean checkPlayServices() 
{
       int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(mContext);
       if (resultCode != ConnectionResult.SUCCESS) 
       {
           //if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) 
           //{
           //    GooglePlayServicesUtil.getErrorDialog(resultCode, mContext, PLAY_SERVICES_RESOLUTION_REQUEST).show();
           //} else {
           //    Log.i(TAG, "This device is not supported.");
           //}
        Log.i("yoyo", "!Google play not found on device");
           return false;
       }
       return true;
   }

private boolean checkPlayServices() {
    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            GooglePlayServicesUtil.getErrorDialog(
                    resultCode, this, REQUEST_CODE_PLAY_SERVICES).show();
        } else {
            Dialog playServicesDialog = DialogFactory.createSimpleOkErrorDialog(
                    this,
                    getString(R.string.dialog_error_title),
                    getString(R.string.error_message_play_services)
            );
            playServicesDialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
                @Override
                public void onDismiss(DialogInterface dialog) {
                    finish();
                }
            });
            playServicesDialog.show();
        }
        return false;
    }
    return true;
}

@Override
public void onRun() throws Exception {
  if (TextSecurePreferences.isGcmDisabled(context)) return;

  Log.w(TAG, "Reregistering GCM...");
  int result = GooglePlayServicesUtil.isGooglePlayServicesAvailable(context);

  if (result != ConnectionResult.SUCCESS) {
    notifyGcmFailure();
  } else {
    String gcmId = GoogleCloudMessaging.getInstance(context).register(REGISTRATION_ID);
    textSecureAccountManager.setGcmId(Optional.of(gcmId));

    TextSecurePreferences.setGcmRegistrationId(context, gcmId);
    TextSecurePreferences.setWebsocketRegistered(context, true);
  }
}

private boolean checkPlayServices() {
    try {
        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
        return resultCode == ConnectionResult.SUCCESS;
    } catch (Exception e) {
        FileLog.e("tmessages", e);
    }
    return true;

    /*if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            GooglePlayServicesUtil.getErrorDialog(resultCode, this, PLAY_SERVICES_RESOLUTION_REQUEST).show();
        } else {
            Log.i("tmessages", "This device is not supported.");
        }
        return false;
    }
    return true;*/
}

/**
 * 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 boolean resolveConnectionFailure(Activity activity,
                                               GoogleApiClient client, ConnectionResult result, int requestCode,
                                               int 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.getErrorCode();
        Dialog dialog = GooglePlayServicesUtil.getErrorDialog(errorCode,
                activity, requestCode);
        if (dialog != null) {
            dialog.show();
        } else {
            // no built-in dialog: show the fallback error message
            showAlert(activity, activity.getString(fallbackErrorMessage));
        }
        return false;
    }
}

private void showRecoveryDialog(int statusCode) {
    Activity activity = getActivity("showRecoveryDialog()");
    if (activity == null) {
        return;
    }

    if (sCanShowAuthUi) {
        sCanShowAuthUi = false;
        LOGD(TAG, "Showing recovery dialog for status code " + statusCode);
        final Dialog d = GooglePlayServicesUtil.getErrorDialog(
                statusCode, activity, REQUEST_RECOVER_FROM_PLAY_SERVICES_ERROR);
        d.show();
    } else {
        LOGD(TAG, "Not showing Play Services recovery dialog because sCanShowSignInUi==false.");
        reportAuthFailure();
    }
}

public static boolean checkGooglePlayServices(final Activity activity) {
    final int googlePlayServicesCheck = GooglePlayServicesUtil.isGooglePlayServicesAvailable(activity);
    switch (googlePlayServicesCheck) {
        case ConnectionResult.SUCCESS:
            return true;
        case ConnectionResult.SERVICE_DISABLED:
        case ConnectionResult.SERVICE_INVALID:
        case ConnectionResult.SERVICE_MISSING:
        case ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED:
            Dialog dialog = GooglePlayServicesUtil.getErrorDialog(googlePlayServicesCheck, activity, 0);
            dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                @Override
                public void onCancel(DialogInterface dialogInterface) {
                    activity.finish();
                }
            });
            dialog.show();
    }
    return false;
}

private boolean checkPlayServices() {
    try {
        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
        return resultCode == ConnectionResult.SUCCESS;
    } catch (Exception e) {
        FileLog.e("tmessages", e);
    }
    return true;

    /*if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            GooglePlayServicesUtil.getErrorDialog(resultCode, this, PLAY_SERVICES_RESOLUTION_REQUEST).show();
        } else {
            Log.i("tmessages", "This device is not supported.");
        }
        return false;
    }
    return true;*/
}

private boolean isGoogleplayServicesAvailableNoDialogs() {

        // Check that Google Play services is available
        int resultCode = GooglePlayServicesUtil
                .isGooglePlayServicesAvailable(getActivity()
                        .getApplicationContext());

        switch (resultCode) {
            case SUCCESS:
                return true;
            case SERVICE_DISABLED:
                return false;
            case SERVICE_MISSING:
                return false;
            case SERVICE_VERSION_UPDATE_REQUIRED:
                return false;
            case CANCELED:
                return false;

        }
        return false;

    }

/**
 * A utility method to validate that the appropriate version of the Google Play Services is
 * available on the device. If not, it will open a dialog to address the issue. The dialog
 * displays a localized message about the error and upon user confirmation (by tapping on
 * dialog) will direct them to the Play Store if Google Play services is out of date or
 * missing, or to system settings if Google Play services is disabled on the device.
 */
public static boolean checkGooglePlayServices(final Activity activity) {
    final int googlePlayServicesCheck = GooglePlayServicesUtil.isGooglePlayServicesAvailable(
            activity);
    switch (googlePlayServicesCheck) {
        case ConnectionResult.SUCCESS:
            return true;
        default:
            Dialog dialog = GooglePlayServicesUtil.getErrorDialog(googlePlayServicesCheck,
                    activity, 0);
            dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                @Override
                public void onCancel(DialogInterface dialogInterface) {
                    activity.finish();
                }
            });
            dialog.show();
    }
    return false;
}

private boolean servicesConnected() {
    // Check that Google Play services is available
    int resultCode =
            GooglePlayServicesUtil.
                    isGooglePlayServicesAvailable(this);
    // If Google Play services is available
    if (ConnectionResult.SUCCESS == resultCode) {
        // In debug mode, log the status
        Log.d("LocationUpdates",
                "Google Play services is available.");
        // Continue
        return true;
        // Google Play services was not available for some reason
    } else {
        Log.e("LocationUpdates",
                "Google Play services is not available.");

    }
    return false;
}

@Override
protected void onResume() {
    super.onResume();

    int errorCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);

    if (errorCode != ConnectionResult.SUCCESS) {
        Dialog errorDialog = GooglePlayServicesUtil
                .getErrorDialog(errorCode, this, REQUEST_ERROR,
                        new DialogInterface.OnCancelListener() {

                            @Override
                            public void onCancel(DialogInterface dialog) {
                                // Leave if services are unavailable.
                                finish();
                            }
                        });

        errorDialog.show();
    }
}

/**
 * Show a {@link android.app.Dialog} with the correct message for a connection error.
 *  @param activity the Activity in which the Dialog should be displayed.
 * @param requestCode the request code from onActivityResult.
 * @param actResp the response code from onActivityResult.
 * @param errorDescription the resource id of a String for a generic error message.
 */
public static void showActivityResultError(Activity activity, int requestCode, int actResp, int errorDescription) {
    if (activity == null) {
        Log.e("BaseGameUtils", "*** No Activity. Can't show failure dialog!");
        return;
    }
    Dialog errorDialog;

    switch (actResp) {
        case GamesActivityResultCodes.RESULT_APP_MISCONFIGURED:
            errorDialog = makeSimpleDialog(activity,
                    activity.getString(R.string.app_misconfigured));
            break;
        case GamesActivityResultCodes.RESULT_SIGN_IN_FAILED:
            errorDialog = makeSimpleDialog(activity,
                    activity.getString(R.string.sign_in_failed));
            break;
        case GamesActivityResultCodes.RESULT_LICENSE_FAILED:
            errorDialog = makeSimpleDialog(activity,
                    activity.getString(R.string.license_failed));
            break;
        default:
            // No meaningful Activity response code, so generate default Google
            // Play services dialog
            final int errorCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(activity);
            errorDialog = GooglePlayServicesUtil.getErrorDialog(errorCode,
                    activity, requestCode, null);
            if (errorDialog == null) {
                // get fallback dialog
                Log.e("BaseGamesUtils",
                        "No standard error dialog available. Making fallback dialog.");
                errorDialog = makeSimpleDialog(activity, activity.getString(errorDescription));
            }
    }

    errorDialog.show();
}

private void handleAuthException(final Activity activity, final Exception e) {
    activity.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (e instanceof GooglePlayServicesAvailabilityException) {
                // The Google Play services APK is old, disabled, or not present.
                // Show a dialog created by Google Play services that allows
                // the user to update the APK
                int statusCode = ((GooglePlayServicesAvailabilityException) e).getConnectionStatusCode();
                Dialog dialog = GooglePlayServicesUtil.getErrorDialog(
                        statusCode, activity, REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR_FOR_URL_SHORTNER);
                dialog.show();
            } else if (e instanceof UserRecoverableAuthException) {
                // Unable to authenticate, such as when the user has not yet granted
                // the app access to the account, but the user can fix this.
                // Forward the user to an activity in Google Play services.
                Intent intent = ((UserRecoverableAuthException) e).getIntent();
                activity.startActivityForResult(
                        intent, REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR_FOR_URL_SHORTNER);

            }
        }
    });
}

public static void handleAuthException(final Activity activity, final Exception e) {
    activity.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (e instanceof GooglePlayServicesAvailabilityException) {
                // The Google Play services APK is old, disabled, or not present.
                // Show a dialog created by Google Play services that allows
                // the user to update the APK
                int statusCode = ((GooglePlayServicesAvailabilityException)e).getConnectionStatusCode();
                Dialog dialog = GooglePlayServicesUtil.getErrorDialog(
                        statusCode, activity, Constants.REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR);
                dialog.show();
            }
            else if (e instanceof UserRecoverableAuthException) {
                // Unable to authenticate, such as when the user has not yet granted
                // the app access to the account, but the user can fix this.
                // Forward the user to an activity in Google Play services.
                Intent intent = ((UserRecoverableAuthException)e).getIntent();
                activity.startActivityForResult(
                        intent, Constants.REQUEST_CODE_RECOVER_FROM_PLAY_SERVICES_ERROR);
            }
        }
    });
}

private void showRecoveryDialog(int statusCode) {
    Activity activity = getActivity("showRecoveryDialog()");
    if (activity == null) {
        return;
    }

    if (sCanShowAuthUi) {
        sCanShowAuthUi = false;
        LOGD(TAG, "Showing recovery dialog for status code " + statusCode);
        final Dialog d = GooglePlayServicesUtil.getErrorDialog(
                statusCode, activity, REQUEST_RECOVER_FROM_PLAY_SERVICES_ERROR);
        d.show();
    } else {
        LOGD(TAG, "Not showing Play Services recovery dialog because sCanShowSignInUi==false.");
        reportAuthFailure();
    }
}

public static boolean checkGooglePlayServices(final Activity activity) {
    final int googlePlayServicesCheck = GooglePlayServicesUtil.isGooglePlayServicesAvailable(activity);
    switch (googlePlayServicesCheck) {
        case ConnectionResult.SUCCESS:
            return true;
        case ConnectionResult.SERVICE_DISABLED:
        case ConnectionResult.SERVICE_INVALID:
        case ConnectionResult.SERVICE_MISSING:
        case ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED:
            Dialog dialog = GooglePlayServicesUtil.getErrorDialog(googlePlayServicesCheck, activity, 0);
            dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                @Override
                public void onCancel(DialogInterface dialogInterface) {
                    activity.finish();
                }
            });
            dialog.show();
    }
    return false;
}

public void connectPlusClient() {
    int val = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
    if (val == ConnectionResult.SUCCESS) {

        if(!mPlusClient.isConnected()) {
            if (mConnectionResult == null) {
                mPlusClient.connect();
                mConnectionProgressDialog.show();
            } else {
                try {
                    mConnectionResult.startResolutionForResult(this, REQUEST_CODE_RESOLVE_ERR);
                } catch (IntentSender.SendIntentException e) {
                    // Try connecting again.
                    mConnectionResult = null;
                    mPlusClient.connect();
                }
            }
        }
    } else {
        Toast.makeText(this, getString(R.string.google_login_message_play_services_not_available), Toast.LENGTH_SHORT).show();
    }
}

private boolean checkPlayServices() {

        int resultCode = GooglePlayServicesUtil
                .isGooglePlayServicesAvailable(getActivity());
        if (resultCode != ConnectionResult.SUCCESS) {
            if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
                GooglePlayServicesUtil.getErrorDialog(resultCode, getActivity(),
                        PLAY_SERVICES_RESOLUTION_REQUEST).show();
            } else {
                Toast.makeText(getContext(),
                        getString(R.string.location_services_not_supported), Toast.LENGTH_LONG)
                        .show();
                getActivity().finish();
            }
            return false;
        }

        return true;
    }

@Override
public void onRun() throws Exception {
  TextSecureAccountManager accountManager = TextSecureCommunicationFactory.createManager(context);
  String                   registrationId = TextSecurePreferences.getGcmRegistrationId(context);

  if (registrationId == null) {
    Log.w(TAG, "GCM registrationId expired, reregistering...");
    int result = GooglePlayServicesUtil.isGooglePlayServicesAvailable(context);

    if (result != ConnectionResult.SUCCESS) {
      notifyGcmFailure();
    } else {
      String gcmId = GoogleCloudMessaging.getInstance(context).register(REGISTRATION_ID);
      accountManager.setGcmId(Optional.of(gcmId));
      TextSecurePreferences.setGcmRegistrationId(context, gcmId);
    }
  }
}

@Override
protected AlertDialog.Builder doInBackground(Void... arg0) {
  String licenseInfo = GooglePlayServicesUtil.getOpenSourceSoftwareLicenseInfo(mActivity);

  AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(mActivity);

  alertDialogBuilder
    .setMessage(licenseInfo)
    .setCancelable(false)
    .setPositiveButton("Close", new DialogInterface.OnClickListener() {
      public void onClick(DialogInterface dialog,int id) {
        dialog.dismiss();
      }
    });

  return alertDialogBuilder;
}

private boolean checkPlayService(FragmentActivity fragmentActivity)
        throws IllegalArgumentException {
    int errorCode =
            GooglePlayServicesUtil.
                    isGooglePlayServicesAvailable(fragmentActivity);
    if (ConnectionResult.SUCCESS != errorCode) {
        if (GooglePlayServicesUtil.isUserRecoverableError(errorCode)) {
            Dialog errorDialog = GooglePlayServicesUtil.getErrorDialog(
                    errorCode, fragmentActivity, REQUEST_CODE);

            ErrorDialogFragment errorFragment =
                    new ErrorDialogFragment();
            errorFragment.setDialog(errorDialog);
            errorFragment.show(fragmentActivity.getSupportFragmentManager(),
                    TAG);

            return false;
        } else {
            throw new IllegalArgumentException("Play Service not supported in this device");
        }
    } else {
        return true;
    }
}

/**
 * Ensures that the device has the correct version of the Google Play
 * Services.
 *
 * @return true if the Google Play Services binary is valid
 */
private boolean isGooglePlayServicesValid(boolean showErrorDialog) {
    // Check for the google play services is available
    final int playStatus = GooglePlayServicesUtil.isGooglePlayServicesAvailable(getContext());
    final boolean isValid = playStatus == ConnectionResult.SUCCESS;

    if (!isValid && showErrorDialog) {
        final Dialog errorDialog = GooglePlayServicesUtil.getErrorDialog(playStatus, getActivity(),
                GOOGLE_PLAY_SERVICES_REQUEST_CODE, new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel(DialogInterface dialog) {
                        if (isAdded()) {
                            getActivity().finish();
                        }
                    }
                });

        if (errorDialog != null)
            errorDialog.show();
    }

    return isValid;
}

private void checkGooglePlayServices() {
  int code = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
  if (code != ConnectionResult.SUCCESS) {
    Dialog dialog = GooglePlayServicesUtil.getErrorDialog(
        code, this, GOOGLE_PLAY_SERVICES_REQUEST_CODE, new DialogInterface.OnCancelListener() {

            @Override
          public void onCancel(DialogInterface dialogInterface) {
            finish();
          }
        });
    if (dialog != null) {
      dialog.show();
      return;
    }
  }
}

public static boolean checkPlayServices(Context act) {

        Activity activity = (Activity)act;

        int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(activity);
        if (resultCode != ConnectionResult.SUCCESS) {
            if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
                GooglePlayServicesUtil.getErrorDialog(resultCode, activity,
                        AppConstants.PLAY_SERVICES_RESOLUTION_REQUEST).show();
            } else {
                Log.i("checkPlayServices", "This device is not supported.");
                activity.finish();
            }
            return false;
        }
        return true;
    }

private void showRecoveryDialog(int statusCode) {
    Activity activity = getActivity("showRecoveryDialog()");
    if (activity == null) {
        return;
    }

    if (sCanShowAuthUi) {
        sCanShowAuthUi = false;
        LOGD(TAG, "Showing recovery dialog for status code " + statusCode);
        final Dialog d = GooglePlayServicesUtil.getErrorDialog(
                statusCode, activity, REQUEST_RECOVER_FROM_PLAY_SERVICES_ERROR);
        d.show();
    } else {
        LOGD(TAG, "Not showing Play Services recovery dialog because sCanShowSignInUi==false.");
        reportAuthFailure();
    }
}

public static boolean checkGooglePlayServices(final Activity activity) {
    final int googlePlayServicesCheck = GooglePlayServicesUtil.isGooglePlayServicesAvailable(activity);
    switch (googlePlayServicesCheck) {
        case ConnectionResult.SUCCESS:
            return true;
        case ConnectionResult.SERVICE_DISABLED:
        case ConnectionResult.SERVICE_INVALID:
        case ConnectionResult.SERVICE_MISSING:
        case ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED:
            Dialog dialog = GooglePlayServicesUtil.getErrorDialog(googlePlayServicesCheck, activity, 0);
            dialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
                @Override
                public void onCancel(DialogInterface dialogInterface) {
                    activity.finish();
                }
            });
            dialog.show();
    }
    return false;
}

private boolean checkGooglePlayServicesAvailable()
{
    final int status = GooglePlayServicesUtil.isGooglePlayServicesAvailable(getApplicationContext());
    if (status == ConnectionResult.SUCCESS)
    {
        return true;
    }

    Log.e("MAIN ACTIVITY", "Google Play Services not available: " + GooglePlayServicesUtil.getErrorString(status));

    if (GooglePlayServicesUtil.isUserRecoverableError(status))
    {
        final Dialog errorDialog = GooglePlayServicesUtil.getErrorDialog(status, this, 1);
        if (errorDialog != null)
        {
            errorDialog.show();
        }
    }

    return false;
}

/**
 * Method to verify google play services on the device
 * */
private boolean checkPlayServices() {
    int resultCode = GooglePlayServicesUtil
            .isGooglePlayServicesAvailable(this);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            GooglePlayServicesUtil.getErrorDialog(resultCode, this,
                    PLAY_SERVICES_RESOLUTION_REQUEST).show();
        } else {
            Toast.makeText(getApplicationContext(),
                    "This device is not supported.", Toast.LENGTH_LONG)
                    .show();
            finish();
        }
        return false;
    }
    return true;
}

public void startUpdates() {
    // If a request is not already underway

    mRequestType = REQUEST_TYPE.START;
    if (GooglePlayServicesUtil.isGooglePlayServicesAvailable(this) != ConnectionResult.SUCCESS) {
        return;
    }

    if (!mInProgress) {
        mInProgress = true; // Indicate that a request is in progress
        mActivityRecognitionClient.connect(); // Request a connection to Location Services
    } else {
        /*
         * A request is already underway. You can handle
         * this situation by disconnecting the client,
         * re-setting the flag, and then re-trying the
         * request.
         */
        // TODO:
    }
}

@Override
public void onResume() {
    super.onResume();

    // Check that Google Play services is available
    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
    if (ConnectionResult.SUCCESS == resultCode) {
        Log.d("Location Updates", "Google Play services is available.");
        return;
    // Google Play services was not available for some reason
    } else {
        // Get the error dialog from Google Play services
        Dialog errorDialog = GooglePlayServicesUtil.getErrorDialog(resultCode, this, CONNECTION_FAILURE_RESOLUTION_REQUEST);
        // If Google Play services can provide an error dialog
        if (errorDialog != null) {
            ErrorDialogFragment errorFragment = new ErrorDialogFragment();
            errorFragment.setDialog(errorDialog);
            errorFragment.show(getSupportFragmentManager(), "Location Updates");
        }
    }
}

@Override
public void onConnectionFailed(ConnectionResult connectionResult) {

    if (mResolvingError) {
        // Already attempting to resolve an error.
        return;
    } else if (connectionResult.hasResolution()) {
        try {
            mResolvingError = true;
            connectionResult.startResolutionForResult(this, REQUEST_RESOLVE_ERROR);
        } catch (IntentSender.SendIntentException e) {
            // There was an error with the resolution intent. Try again.
            googleApiClient.connect();
        }
    } else {
        // Show dialog using GooglePlayServicesUtil.getErrorDialog()
        GooglePlayServicesUtil.getErrorDialog(connectionResult.getErrorCode(),this,GooglePlayServicesUtil.GOOGLE_PLAY_SERVICES_VERSION_CODE).show();
        mResolvingError = true;
    }

    Log.i(TAG, "Location services connection failed with code " + connectionResult.getErrorCode());

}

@Override
protected void onResume() {
    super.onResume();

    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);

    if (resultCode == ConnectionResult.SUCCESS) {
        mRecyclerView.setAdapter(mListAdapter);
    } else {
        GooglePlayServicesUtil.getErrorDialog(resultCode, this, 1).show();
    }

    if (mListAdapter != null) {
        for (MapView m : mListAdapter.getMapViews()) {
            m.onResume();
        }
    }
}

/**
 * Method to verify google play services on the device
 * */
private boolean checkPlayServices() {
    int resultCode = GooglePlayServicesUtil
            .isGooglePlayServicesAvailable(this);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            GooglePlayServicesUtil.getErrorDialog(resultCode, this,
                    PLAY_SERVICES_RESOLUTION_REQUEST).show();
        } else {
            Toast.makeText(getApplicationContext(),
                    "This device is not supported.", Toast.LENGTH_LONG)
                    .show();
            finish();
        }
        return false;
    }
    return true;
}

/**
 * Called if the device does not have Google Play Services installed.
 */
void showGooglePlayServicesAvailabilityErrorDialog(final int connectionStatusCode) {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            try {
                Dialog dialog = GooglePlayServicesUtil.getErrorDialog(
                        connectionStatusCode, MainActivity.this, REQUEST_GOOGLE_PLAY_SERVICES);
                dialog.show();
            } catch (Exception e) {
                Log.e(TAG, "Unable to obtain Google Play!.", e);
            }

        }
    });
}

public static PendingIntent getRecoveryIfSuggested$12f08959(Context paramContext, String paramString)
  throws IOException, UserRecoverableAuthException, GoogleAuthException
{
  zzx.zzcy("Calling this from your main thread can lead to deadlock");
  try
  {
    GooglePlayServicesUtil.zzae(paramContext.getApplicationContext());
    final Bundle localBundle = new Bundle();
    localBundle.putString(KEY_ANDROID_PACKAGE_NAME, paramContext.getPackageName());
    zza local3 = new zza() {};
    RecoveryDecision localRecoveryDecision = (RecoveryDecision)zza(paramContext, zzVm, local3);
    if ((localRecoveryDecision.showRecoveryInterstitial) && (localRecoveryDecision.isRecoveryInterstitialAllowed)) {
      return localRecoveryDecision.recoveryIntent;
    }
  }
  catch (GooglePlayServicesRepairableException localGooglePlayServicesRepairableException)
  {
    throw new GooglePlayServicesAvailabilityException(localGooglePlayServicesRepairableException.zzVA, localGooglePlayServicesRepairableException.getMessage(), new Intent(localGooglePlayServicesRepairableException.mIntent));
  }
  catch (GooglePlayServicesNotAvailableException localGooglePlayServicesNotAvailableException)
  {
    throw new GoogleAuthException(localGooglePlayServicesNotAvailableException.getMessage());
  }
  return null;
}

public static void initialize(Context paramContext)
{
  zzja.zzb(new Callable()
  {
    private Void zzdv()
    {
      zzf localzzf = zzp.zzbR();
      Context localContext1 = this.zzsR;
      Context localContext2;
      synchronized (localzzf.zzqp)
      {
        if (localzzf.zzqM) {
          break label74;
        }
        localContext2 = GooglePlayServicesUtil.getRemoteContext(localContext1);
        if (localContext2 != null) {}
      }
      zzp.zzbP();
      localzzf.zzvG = localContext2.getSharedPreferences("google_ads_flags", 1);
      localzzf.zzqM = true;
      label74:
      return null;
    }
  });
}

@Override
protected void onResume() {
    super.onResume();

    // Check is Google Play Services available
    int connectionResult = GooglePlayServicesUtil.isGooglePlayServicesAvailable(getApplicationContext());

    if (connectionResult != ConnectionResult.SUCCESS) {
        // Google Play Services is NOT available. Show appropriate error dialog
        GooglePlayServicesUtil.showErrorDialogFragment(connectionResult, this, 0, new DialogInterface.OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                finish();
            }
        });
    } else {
        apiClient.connect();
    }
}

private boolean isGoogelPlayInstalled() {
    int resultCode = GooglePlayServicesUtil
            .isGooglePlayServicesAvailable(context);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            GooglePlayServicesUtil.getErrorDialog(resultCode, mRegisterActivity,
                    ACTION_PLAY_SERVICES_DIALOG).show();
        } else {
            Toast.makeText(context,
                    "Google Play Service is not installed. Cannot receive notifications",
                    Toast.LENGTH_SHORT).show();

        }
        return false;
    }
    return true;

}

/**
 * Check the device to make sure it has the Google Play Services APK. If
 * it doesn't, display a dialog that allows users to download the APK from
 * the Google Play Store or enable it in the device's system settings.
 */
public static boolean checkPlayServices(Context context) {
    int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(context);
    if (resultCode != ConnectionResult.SUCCESS) {
        if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
            Log.d(TAG, "Google Play Services is not available, but the issue is User Recoverable");
            if (context instanceof Activity) {
                GooglePlayServicesUtil.getErrorDialog(resultCode, (Activity) context, PLAY_SERVICES_RESOLUTION_REQUEST).show();
            }
        } else {
            /**
             * TODO: Handle all issue related to non User recoverable error
             */
            Log.e(TAG, "Non user recoverable error while checking for Play Services");
        }
        return false;
    }
    return true;
}