Java 类com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener 实例源码

private void initAuth() {
    // Configure sign-in to request the user's ID, email address, and basic
    // profile. ID and basic profile are included in DEFAULT_SIGN_IN.
    GoogleSignInOptions gso = new GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
            .requestEmail()
            .build();

    // Build a GoogleApiClient with access to the Google Sign-In API and the
    // options specified by gso.
    googleApiClient = new GoogleApiClient.Builder(this)
            .enableAutoManage(this, new OnConnectionFailedListener() {
                @Override
                public void onConnectionFailed(ConnectionResult connectionResult) {
                    finish();
                }
            })
            .addApi(Auth.GOOGLE_SIGN_IN_API, gso)
            .build();

    signInSilently();
}

private void zza(int paramInt, ConnectionResult paramConnectionResult)
{
  Log.w("GmsSupportLifecycleFrag", "Unresolved error while connecting client. Stopping auto-manage.");
  zza localzza1 = (zza)this.zzaqI.get(paramInt);
  if (localzza1 != null)
  {
    zza localzza2 = (zza)this.zzaqI.get(paramInt);
    this.zzaqI.remove(paramInt);
    if (localzza2 != null)
    {
      localzza2.zzaqK.unregisterConnectionFailedListener(localzza2);
      localzza2.zzaqK.disconnect();
    }
    GoogleApiClient.OnConnectionFailedListener localOnConnectionFailedListener = localzza1.zzaqL;
    if (localOnConnectionFailedListener != null) {
      localOnConnectionFailedListener.onConnectionFailed(paramConnectionResult);
    }
  }
  zzps();
}

public WearableConnectivity(Context context, final WearableEvents wearableEvents)
{
    this.apiClient = new GoogleApiClient.Builder(context).addConnectionCallbacks(new ConnectionCallbacks()
    {
        @Override
        public void onConnected(Bundle connectionHint)
        {
            onClientConnected(wearableEvents);
        }

        @Override
        public void onConnectionSuspended(int cause)
        {
            wearableEvents.onConnectedFail();
        }
    }).addOnConnectionFailedListener(new OnConnectionFailedListener()
    {
        @Override
        public void onConnectionFailed(ConnectionResult result)
        {
            wearableEvents.onConnectedFail();
        }
    }).addApi(Wearable.API).build();
}

public WearableConnectivity(Context context, final WearableEvents wearableEvents)
{
    this.apiClient = new GoogleApiClient.Builder(context).addConnectionCallbacks(new ConnectionCallbacks()
    {
        @Override
        public void onConnected(Bundle connectionHint)
        {
            onClientConnected(wearableEvents);
        }

        @Override
        public void onConnectionSuspended(int cause)
        {
            wearableEvents.onConnectedFail();
        }
    }).addOnConnectionFailedListener(new OnConnectionFailedListener()
    {
        @Override
        public void onConnectionFailed(ConnectionResult result)
        {
            wearableEvents.onConnectedFail();
        }
    }).addApi(Wearable.API).build();
}

public fl(Context paramContext, String paramString1, String paramString2, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, String[] paramArrayOfString, int paramInt1, View paramView, boolean paramBoolean1, boolean paramBoolean2, int paramInt2, int paramInt3)
{
  super(paramContext, paramConnectionCallbacks, paramOnConnectionFailedListener, paramArrayOfString);
  this.tO = paramString1;
  this.jG = ((String)eg.f(paramString2));
  this.tU = new Binder();
  this.tP = new HashMap();
  this.tS = fq.a(this, paramInt1);
  setViewForPopups(paramView);
  this.tA = paramBoolean2;
  this.tB = paramInt2;
  this.tV = hashCode();
  this.tW = paramBoolean1;
  this.tX = paramInt3;
  registerConnectionCallbacks(this);
  registerConnectionFailedListener(this);
}

public final iu h(Context paramAnonymousContext, dt paramAnonymousdt, GoogleApiClient.ApiOptions paramAnonymousApiOptions, GoogleApiClient.ConnectionCallbacks paramAnonymousConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramAnonymousOnConnectionFailedListener)
{
  eg.b(paramAnonymousContext instanceof Activity, "An Activity must be used for Wallet APIs");
  Activity localActivity = (Activity)paramAnonymousContext;
  boolean bool;
  if ((paramAnonymousApiOptions == null) || ((paramAnonymousApiOptions instanceof Wallet.WalletOptions)))
    bool = true;
  else
    bool = false;
  eg.b(bool, "WalletOptions must be used for Wallet APIs");
  Wallet.WalletOptions localWalletOptions1;
  if (paramAnonymousApiOptions != null)
    localWalletOptions1 = (Wallet.WalletOptions)paramAnonymousApiOptions;
  else
    localWalletOptions1 = new Wallet.WalletOptions(null);
  Wallet.WalletOptions localWalletOptions2 = localWalletOptions1;
  return new iu(localActivity, paramAnonymousConnectionCallbacks, paramAnonymousOnConnectionFailedListener, localWalletOptions2.environment, paramAnonymousdt.getAccountName(), localWalletOptions2.theme);
}

private GoogleApiClient createGoogleWearableAPIClient() {
    return new GoogleApiClient.Builder(this)
            .addConnectionCallbacks(new ConnectionCallbacks() {
                @Override
                public void onConnected(Bundle connectionHint) {
                    Log.d(TAG, "onConnected: " + connectionHint);
                    // Now you can use the data layer API
                }

                @Override
                public void onConnectionSuspended(int cause) {
                    Log.d(TAG, "onDisconnected "+ cause);
                }

            })
            .addOnConnectionFailedListener(new OnConnectionFailedListener() {
                @Override
                public void onConnectionFailed(ConnectionResult result) {
                    Log.d(TAG, "onConnectionFailed: " + result);
                }
            })
                    // Request access only to the Wearable API
            .addApi(Wearable.API)
            .build();
}

/**
 * Set location service listeners.
 *
 * @param connectionListener       ConnectionCallbacks.
 * @param connectionFailedListener OnConnectionFailedListener.
 */
void setListeners(ConnectionCallbacks connectionListener,
                  OnConnectionFailedListener connectionFailedListener) {
    // Create an instance of the Google Play services API client
    this.googleApiClient = new GoogleApiClient.Builder(context)
            .addConnectionCallbacks(connectionListener)
            .addOnConnectionFailedListener(connectionFailedListener)
            .addApi(LocationServices.API)
            .build();
}

public zzi(Context paramContext, Looper paramLooper, boolean paramBoolean, com.google.android.gms.common.internal.zzf paramzzf, Bundle paramBundle, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 44, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
  this.zzbMe = paramBoolean;
  this.zzapu = paramzzf;
  this.zzbLN = paramBundle;
  this.zzaty = paramzzf.zzaty;
}

public zza(int paramInt, GoogleApiClient paramGoogleApiClient, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  this.zzaqJ = paramInt;
  this.zzaqK = paramGoogleApiClient;
  this.zzaqL = paramOnConnectionFailedListener;
  paramGoogleApiClient.registerConnectionFailedListener(this);
}

public zznd(Context paramContext, Lock paramLock, Looper paramLooper, zzf paramzzf, GoogleApiAvailability paramGoogleApiAvailability, Api.zza<? extends zzwz, zzxa> paramzza, Map<Api<?>, Integer> paramMap, List<GoogleApiClient.ConnectionCallbacks> paramList, List<GoogleApiClient.OnConnectionFailedListener> paramList1, Map<Api.zzc<?>, Api.zzb> paramMap1, int paramInt1, int paramInt2, ArrayList<zzmw> paramArrayList)
{
  this.mContext = paramContext;
  this.zzXP = paramLock;
  this.zzapI = new zzk(paramLooper, this.zzapX);
  this.zzoD = paramLooper;
  this.zzapO = new zza(paramLooper);
  this.zzaon = paramGoogleApiAvailability;
  this.zzaol = paramInt1;
  if (this.zzaol >= 0) {
    this.zzapV = Integer.valueOf(paramInt2);
  }
  this.zzapv = paramMap;
  this.zzapQ = paramMap1;
  this.zzapU = paramArrayList;
  Iterator localIterator1 = paramList.iterator();
  while (localIterator1.hasNext())
  {
    GoogleApiClient.ConnectionCallbacks localConnectionCallbacks = (GoogleApiClient.ConnectionCallbacks)localIterator1.next();
    this.zzapI.registerConnectionCallbacks(localConnectionCallbacks);
  }
  Iterator localIterator2 = paramList1.iterator();
  while (localIterator2.hasNext())
  {
    GoogleApiClient.OnConnectionFailedListener localOnConnectionFailedListener = (GoogleApiClient.OnConnectionFailedListener)localIterator2.next();
    this.zzapI.registerConnectionFailedListener(localOnConnectionFailedListener);
  }
  this.zzapu = paramzzf;
  this.zzaoo = paramzza;
}

public final void unregisterConnectionFailedListener(GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  zzk localzzk = this.zzapI;
  zzx.zzC(paramOnConnectionFailedListener);
  synchronized (localzzk.zzqp)
  {
    if (!localzzk.zzaug.remove(paramOnConnectionFailedListener)) {
      Log.w("GmsClientEvents", "unregisterConnectionFailedListener(): listener " + paramOnConnectionFailedListener + " not found");
    }
    return;
  }
}

public final void registerConnectionFailedListener(GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  zzx.zzC(paramOnConnectionFailedListener);
  synchronized (this.zzqp)
  {
    if (this.zzaug.contains(paramOnConnectionFailedListener))
    {
      Log.w("GmsClientEvents", "registerConnectionFailedListener(): listener " + paramOnConnectionFailedListener + " is already registered");
      return;
    }
    this.zzaug.add(paramOnConnectionFailedListener);
  }
}

private zzj(Context paramContext, Looper paramLooper, zzl paramzzl, GoogleApiAvailability paramGoogleApiAvailability, int paramInt, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  this.mContext = ((Context)zzx.zzb(paramContext, "Context must not be null"));
  this.zzoD = ((Looper)zzx.zzb(paramLooper, "Looper must not be null"));
  this.zzatM = ((zzl)zzx.zzb(paramzzl, "Supervisor must not be null"));
  this.zzaon = ((GoogleApiAvailability)zzx.zzb(paramGoogleApiAvailability, "API availability must not be null"));
  this.mHandler = new zzb(paramLooper);
  this.zzatV = paramInt;
  this.zzapu = ((zzf)zzx.zzC(paramzzf));
  this.zzRE = paramzzf.zzRE;
  this.zzXp = zzb(paramzzf.zzatw);
  this.zzatT = paramConnectionCallbacks;
  this.zzatU = paramOnConnectionFailedListener;
}

public zzn(Context paramContext, Looper paramLooper, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, String paramString, zzf paramzzf)
{
  super(paramContext.getApplicationContext(), paramLooper, 5, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
  this.mContext = paramContext;
  this.zzbxg = paramString;
  this.zzUb = paramzzf.zzUb;
}

/**
 * Register the listeners and then connect the client.
 */
public static GoogleApiClient connect(GoogleApiClient client, ConnectedListener connected,
                                      OnConnectionFailedListener failed) {
    client.registerConnectionCallbacks(new ConnectionListener(connected));
    client.registerConnectionFailedListener(failed);
    client.connect();
    return client;
}

public void initGoogleApiClient(ConnectionCallbacks callbacks, OnConnectionFailedListener listener) {
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .addApi(Plus.API)
            .addScope(Plus.SCOPE_PLUS_LOGIN)
            .addConnectionCallbacks(callbacks)
            .addOnConnectionFailedListener(listener)
            .build();
}

public final dg c(Context paramAnonymousContext, dt paramAnonymousdt, GoogleApiClient.ApiOptions paramAnonymousApiOptions, GoogleApiClient.ConnectionCallbacks paramAnonymousConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramAnonymousOnConnectionFailedListener)
{
  eg.b(paramAnonymousApiOptions, "Setting the API options is required.");
  eg.b(paramAnonymousApiOptions instanceof Cast.CastOptions, "Must provide valid CastOptions!");
  Cast.CastOptions localCastOptions = (Cast.CastOptions)paramAnonymousApiOptions;
  return new dg(paramAnonymousContext, localCastOptions.ks, Cast.CastOptions.a(localCastOptions), localCastOptions.kt, paramAnonymousConnectionCallbacks, paramAnonymousOnConnectionFailedListener);
}

public dw(Context paramContext, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, String[] paramArrayOfString)
{
  this.mContext = ((Context)eg.f(paramContext));
  this.ne = new dx(paramContext, this, null);
  this.mHandler = new a(paramContext.getMainLooper());
  a(paramArrayOfString);
  this.jF = paramArrayOfString;
  registerConnectionCallbacks((GoogleApiClient.ConnectionCallbacks)eg.f(paramConnectionCallbacks));
  registerConnectionFailedListener((GoogleApiClient.OnConnectionFailedListener)eg.f(paramOnConnectionFailedListener));
}

public iu(Activity paramActivity, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, int paramInt1, String paramString, int paramInt2)
{
  super(paramActivity, paramConnectionCallbacks, paramOnConnectionFailedListener, new String[0]);
  this.gs = paramActivity;
  this.Hi = paramInt1;
  this.jG = paramString;
  this.mTheme = paramInt2;
}

/**
 * Construct a client using AutoManage functionality.
 */
protected synchronized void rebuildGoogleApiClient() {
    // When we build the GoogleApiClient we specify where connected and connection failed
    // callbacks should be returned, which Google APIs our app uses and which OAuth 2.0
    // scopes our app requests. When using enableAutoManage to register the failed connection
    // listener it will only be called back when auto-resolution attempts were not
    // successful or possible. A normal ConnectionFailedListener is also registered below to
    // notify the activity when it needs to stop making API calls.
    mGoogleApiClient = new GoogleApiClient.Builder(this)
            .enableAutoManage(this /* FragmentActivity */,
                    0 /* googleApiClientId used when auto-managing multiple googleApiClients */,
                    this /* OnConnectionFailedListener */)
            .addConnectionCallbacks(this /* ConnectionCallbacks */)
            // Register a connection listener that will notify on disconnect (including ones
            // caused by calling disconnect on the GoogleApiClient).
            .addOnConnectionFailedListener(new OnConnectionFailedListener() {
                @Override
                public void onConnectionFailed(ConnectionResult connectionResult) {
                    googleApiClientConnectionStateChange(true);
                }
            })
            .addApi(Plus.API)
            .addScope(new Scope(Scopes.PLUS_ME))
                    // TODO(developer): Specify any additional API Scopes or APIs you need here.
                    // The GoogleApiClient will ensure these APIs are available, and the Scopes
                    // are approved before invoking the onConnected callbacks.
            .build();
}

protected GoogleApiClient getGoogleApiClient() {
    if (getActivity() == null) {
        postCallback(new GoogleApiClientException(ErrorType.NotAttachedToActivity, 1));
        return null;
    }

    if (mGoogleApiClient == null) {
        mGoogleApiClient = new GoogleApiClient.Builder(getActivity())
                .addApi(Wallet.API, new Wallet.WalletOptions.Builder()
                        .setEnvironment(GooglePayment.getEnvironment(getConfiguration().getAndroidPay()))
                        .setTheme(WalletConstants.THEME_LIGHT)
                        .build())
                .build();
    }

    if (!mGoogleApiClient.isConnected() && !mGoogleApiClient.isConnecting()) {
        mGoogleApiClient.registerConnectionCallbacks(new ConnectionCallbacks() {
            @Override
            public void onConnected(Bundle bundle) {}

            @Override
            public void onConnectionSuspended(int i) {
                postCallback(new GoogleApiClientException(ErrorType.ConnectionSuspended, i));
            }
        });

        mGoogleApiClient.registerConnectionFailedListener(new OnConnectionFailedListener() {
            @Override
            public void onConnectionFailed(ConnectionResult connectionResult) {
                postCallback(new GoogleApiClientException(ErrorType.ConnectionFailed, connectionResult.getErrorCode()));
            }
        });

        mGoogleApiClient.connect();
    }

    return mGoogleApiClient;
}

public void connect(ConnectionCallbacks mConnectionCallbacks,
        OnConnectionFailedListener mOnConnectionFailedListener) {
    if (mGoogleApiClient == null) {
        mGoogleApiClient = new GoogleApiClient.Builder(mContext)
                .addApi(Drive.API)
                .addScope(Drive.SCOPE_FILE)
                .addScope(Drive.SCOPE_APPFOLDER)        
                // required for App Folder sample
                .addConnectionCallbacks(mConnectionCallbacks)
                .addOnConnectionFailedListener(mOnConnectionFailedListener)
                .build();
    }
    mGoogleApiClient.connect();
}

private void initGoogleApliClient(){

    googleAPIClient = new GoogleApiClient.Builder(this)
    .addConnectionCallbacks(
            (GoogleApiClient.ConnectionCallbacks) this)
    .addOnConnectionFailedListener(
            (GoogleApiClient.OnConnectionFailedListener) this)
    .addApi(Plus.API).addScope(Plus.SCOPE_PLUS_LOGIN).build();

}

public void init(int myDeviceID) {
    deviceID = myDeviceID;
    activity.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            client = new GoogleApiClient.Builder(activity)
            .addConnectionCallbacks(new ConnectionCallbacks(){
                @Override
                public void onConnected(Bundle m_bundle) {
                    Log.i("godot", "PlayGameServices: connection callbacks onConnected ");
                    isGooglePlayConnected = true;
                    Log.i("godot", "PlayGameServices: calling godot above ");
                }
                @Override
                public void onConnectionSuspended(int m_cause) {
                    Log.i("godot", "PlayGameServices: connection callbacks onConnectionSuspended int cause "+String.valueOf(m_cause));
                }
            })
            .addOnConnectionFailedListener(new OnConnectionFailedListener() {
                @Override
                public void onConnectionFailed(ConnectionResult m_result) {
                    Log.i("godot", "PlayGameServices: onConnectionFailed result code: "+String.valueOf(m_result));

                    if (isResolvingConnectionFailure) {
                        return;
                    }

        if(!isIntentInProgress && m_result.hasResolution()) {
                        try {
                            isIntentInProgress = true;
                            activity.startIntentSenderForResult(m_result.getResolution().getIntentSender(), RC_SIGN_IN, null, 0, 0, 0);
                        } catch (SendIntentException ex) {
                            isIntentInProgress = false;
                            client.connect();                                                          
                        }
                        isResolvingConnectionFailure = true;      
                    }
                }
            })
            .addApi(Games.API).addScope(Games.SCOPE_GAMES)
            .addApi(Plus.API).addScope(Plus.SCOPE_PLUS_LOGIN)
            .addApi(Drive.API).addScope(Drive.SCOPE_APPFOLDER)
            .build();
        }
    });
}

public static GoogleApiClient buildGoogleApiClientForCar(Context paramContext, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, CarConnectionListener paramCarConnectionListener)
{
  return new GoogleApiClient.Builder(paramContext).addApi(API, new CarOptions(new Car.CarOptions.Builder(paramCarConnectionListener, (byte)0), (byte)0)).addConnectionCallbacks(paramConnectionCallbacks).addOnConnectionFailedListener(paramOnConnectionFailedListener).build();
}

public zzce(Context paramContext, Looper paramLooper, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, zzf paramzzf)
{
  super(paramContext, paramLooper, 14, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public zzc(Context paramContext, Looper paramLooper, com.google.android.gms.common.internal.zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 63, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public zzi(Context paramContext, Looper paramLooper, com.google.android.gms.common.internal.zzf paramzzf, zzxa paramzzxa, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, ExecutorService paramExecutorService)
{
  this(paramContext, paramLooper, true, paramzzf, localBundle, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public zzmr(Context paramContext, Looper paramLooper, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 40, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public zzry(Context paramContext, Looper paramLooper, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 28, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public zzot(Context paramContext, Looper paramLooper, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 20, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public final void registerConnectionFailedListener(GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  this.zzapI.registerConnectionFailedListener(paramOnConnectionFailedListener);
}

public final void zze(ConnectionResult paramConnectionResult)
{
  if (!GoogleApiAvailability.isPlayServicesPossiblyUpdating(this.mContext, paramConnectionResult.zzakr)) {
    zzpi();
  }
  zzk localzzk;
  boolean bool;
  if (!this.zzapL)
  {
    localzzk = this.zzapI;
    if (Looper.myLooper() != localzzk.mHandler.getLooper()) {
      break label151;
    }
    bool = true;
    zzx.zza(bool, "onConnectionFailure must only be called on the Handler thread");
    localzzk.mHandler.removeMessages(1);
  }
  for (;;)
  {
    synchronized (localzzk.zzqp)
    {
      ArrayList localArrayList = new ArrayList(localzzk.zzaug);
      int i = localzzk.zzaui.get();
      Iterator localIterator = localArrayList.iterator();
      if (localIterator.hasNext())
      {
        GoogleApiClient.OnConnectionFailedListener localOnConnectionFailedListener = (GoogleApiClient.OnConnectionFailedListener)localIterator.next();
        if ((!localzzk.zzauh) || (localzzk.zzaui.get() != i))
        {
          this.zzapI.zzqv();
          return;
          label151:
          bool = false;
          break;
        }
        if (!localzzk.zzaug.contains(localOnConnectionFailedListener)) {
          continue;
        }
        localOnConnectionFailedListener.onConnectionFailed(paramConnectionResult);
      }
    }
  }
}

public zzvm(Context paramContext, Looper paramLooper, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 45, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
  this.mContext = paramContext;
}

public zzad(Context paramContext, Looper paramLooper, int paramInt, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener, zzf paramzzf, Api.zzd paramzzd)
{
  super(paramContext, paramLooper, paramInt, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
  this.zzauJ = paramzzd;
}

public zzj(Context paramContext, Looper paramLooper, int paramInt, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  this(paramContext, paramLooper, zzl.zzav(paramContext), GoogleApiAvailability.getInstance(), paramInt, paramzzf, (GoogleApiClient.ConnectionCallbacks)zzx.zzC(paramConnectionCallbacks), (GoogleApiClient.OnConnectionFailedListener)zzx.zzC(paramOnConnectionFailedListener));
}

public zzn(Context paramContext, Looper paramLooper, zzf paramzzf, GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  super(paramContext, paramLooper, 93, paramzzf, paramConnectionCallbacks, paramOnConnectionFailedListener);
}

public void init_GGPGS(int device_id) {
        Log.d("------- godot --------", "init_GGPGS MODULE");
        mDevice_id = device_id;
        mActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                mGoogleApiClient = new GoogleApiClient.Builder(mActivity)
                        .addConnectionCallbacks(new ConnectionCallbacks() {
                            @Override
                            public void onConnected(Bundle m_bundle) {
                                Log.d("------- godot --------", "connectioncallbacks on connected ");
                                mGooglePlayConnected = true;
                                Log.d("------- godot --------", "calling godot above ");
                            }

                            @Override
                            public void onConnectionSuspended(int m_cause) {
                                Log.w("------- godot --------", "connectioncallbacks onConnectionSuspended int cause " + String.valueOf(m_cause));
                                mGoogleApiClient.connect();
                            }
                        })
                        .addOnConnectionFailedListener(new OnConnectionFailedListener() {
                            @Override
                            public void onConnectionFailed(ConnectionResult mResult) {
                                Log.w("------- godot --------", "onConnectionFailed result code: " + String.valueOf(mResult));
                                if (mResolvingConnectionFailure) {
                                    // already resolving
                                    return;
                                }

                                // if the sign-in button was clicked or if auto sign-in is enabled,
                                // launch the sign-in flow
                                if (mSignInClicked || mAutoStartSignInflow) {
                                    mAutoStartSignInflow = false;
                                    mSignInClicked = false;
                                    mResolvingConnectionFailure = true;

                                    // Attempt to resolve the connection failure using BaseGameUtils.
                                    // The R.string.signin_other_error value should reference a generic
                                    // error string in your strings.xml file, such as "There was
                                    // an issue with sign-in, please try again later."
                                    if (!BaseGameUtils.resolveConnectionFailure(mActivity,
                                            mGoogleApiClient, mResult,
                                            RC_SIGN_IN, mActivity.getString(R.string.gamehelper_unknown_error))) {
                                        mResolvingConnectionFailure = false;
                                    }
                                }
                            }
                        })
                        .addApi(Games.API).addScope(Games.SCOPE_GAMES)
//                        .addApi(Plus.API).addScope(Plus.SCOPE_PLUS_LOGIN)
                        .addApi(Drive.API).addScope(Drive.SCOPE_APPFOLDER)
                        .build();

                sign_in();
            }
        });
    }

@Deprecated
public hm(Context paramContext, GooglePlayServicesClient.ConnectionCallbacks paramConnectionCallbacks, GooglePlayServicesClient.OnConnectionFailedListener paramOnConnectionFailedListener)
{
  this(paramContext, new dw.c(paramConnectionCallbacks), new dw.g(paramOnConnectionFailedListener));
}