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

public final boolean handleMessage(Message paramMessage)
{
  if (paramMessage.what == 1)
  {
    GoogleApiClient.ConnectionCallbacks localConnectionCallbacks = (GoogleApiClient.ConnectionCallbacks)paramMessage.obj;
    synchronized (this.zzqp)
    {
      if ((this.zzauh) && (this.zzaud.isConnected()) && (this.zzaue.contains(localConnectionCallbacks))) {
        localConnectionCallbacks.onConnected(null);
      }
      return true;
    }
  }
  Log.wtf("GmsClientEvents", "Don't know how to handle message: " + paramMessage.what, new Exception());
  return false;
}

public final void registerConnectionCallbacks(GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
{
  zzx.zzC(paramConnectionCallbacks);
  synchronized (this.zzqp)
  {
    if (this.zzaue.contains(paramConnectionCallbacks))
    {
      Log.w("GmsClientEvents", "registerConnectionCallbacks(): listener " + paramConnectionCallbacks + " is already registered");
      if (this.zzaud.isConnected()) {
        this.mHandler.sendMessage(this.mHandler.obtainMessage(1, paramConnectionCallbacks));
      }
      return;
    }
    this.zzaue.add(paramConnectionCallbacks);
  }
}

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 void J(int paramInt)
{
  this.mHandler.removeMessages(1);
  while (true)
  {
    int i;
    synchronized (this.pt)
    {
      this.pv = true;
      ArrayList localArrayList2 = this.pt;
      i = 0;
      int j = localArrayList2.size();
      if ((i < j) && (this.ps.bp()))
      {
        if (this.pt.contains(localArrayList2.get(i)))
          ((GoogleApiClient.ConnectionCallbacks)localArrayList2.get(i)).onConnectionSuspended(paramInt);
      }
      else
      {
        this.pv = false;
        return;
      }
    }
    i++;
  }
}

public final void registerConnectionCallbacks(GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
{
  eg.f(paramConnectionCallbacks);
  synchronized (this.pt)
  {
    if (this.pt.contains(paramConnectionCallbacks))
    {
      new StringBuilder("registerConnectionCallbacks(): listener ").append(paramConnectionCallbacks).append(" is already registered");
    }
    else
    {
      if (this.pv)
        this.pt = new ArrayList(this.pt);
      this.pt.add(paramConnectionCallbacks);
    }
  }
  if (this.ps.isConnected())
    this.mHandler.sendMessage(this.mHandler.obtainMessage(1, paramConnectionCallbacks));
}

public final void unregisterConnectionCallbacks(GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
{
  eg.f(paramConnectionCallbacks);
  synchronized (this.pt)
  {
    if (this.pt != null)
    {
      if (this.pv)
        this.pt = new ArrayList(this.pt);
      if (!this.pt.remove(paramConnectionCallbacks))
        new StringBuilder("unregisterConnectionCallbacks(): listener ").append(paramConnectionCallbacks).append(" not found");
      else if ((this.pv) && (!this.pu.contains(paramConnectionCallbacks)))
        this.pu.add(paramConnectionCallbacks);
    }
    return;
  }
}

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 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 unregisterConnectionCallbacks(GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
{
  zzk localzzk = this.zzapI;
  zzx.zzC(paramConnectionCallbacks);
  synchronized (localzzk.zzqp)
  {
    if (!localzzk.zzaue.remove(paramConnectionCallbacks)) {
      Log.w("GmsClientEvents", "unregisterConnectionCallbacks(): listener " + paramConnectionCallbacks + " not found");
    }
    while (!localzzk.zzauj) {
      return;
    }
    localzzk.zzauf.add(paramConnectionCallbacks);
  }
}

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;
}

@Override
public void onConnectionSuspended(int i) {
    // If your connection gets lost at some point,
    // you'll be able to determine the reason and react to it here.
    if (i == ConnectionCallbacks.CAUSE_NETWORK_LOST) {
        Utils.logDebug(TAG, "Connection lost.  Cause: Network Lost.");
    } else if (i == ConnectionCallbacks.CAUSE_SERVICE_DISCONNECTED) {
        Utils.logDebug(TAG, "Connection lost.  Reason: Service Disconnected");
    }
    // Send the hint to Activity for UI updates
    ((MainActivity) mActivity).onFitStatusUpdated(false);
    // Attempt to reconnect
    connect();
}

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 final boolean isConnectionCallbacksRegistered(GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
{
  eg.f(paramConnectionCallbacks);
  synchronized (this.pt)
  {
    boolean bool = this.pt.contains(paramConnectionCallbacks);
    return bool;
  }
}

public final void handleMessage(Message paramMessage)
{
  if (paramMessage.what == 1)
    synchronized (dx.a(dx.this))
    {
      if ((dx.b(dx.this).bp()) && (dx.b(dx.this).isConnected()) && (dx.a(dx.this).contains(paramMessage.obj)))
      {
        Bundle localBundle = dx.b(dx.this).aU();
        ((GoogleApiClient.ConnectionCallbacks)paramMessage.obj).onConnected(localBundle);
      }
      return;
    }
  Log.wtf("GmsClientEvents", "Don't know how to handle this message.");
}

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;
}

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 registerConnectionCallbacks(GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
{
  this.zzapI.registerConnectionCallbacks(paramConnectionCallbacks);
}

public final void zzcM(int paramInt)
{
  if ((paramInt == 1) && (!this.zzapL))
  {
    this.zzapL = true;
    if (this.zzapP == null) {
      this.zzapP = ((zzc)zznh.zza$645b353c(this.mContext.getApplicationContext(), new zzc(this)));
    }
    this.zzapO.sendMessageDelayed(this.zzapO.obtainMessage(1), this.zzapM);
    this.zzapO.sendMessageDelayed(this.zzapO.obtainMessage(2), this.zzapN);
  }
  Iterator localIterator1 = this.zzapS.iterator();
  while (localIterator1.hasNext()) {
    ((zze)localIterator1.next()).zzF(new Status(8, "The connection to Google Play services was lost"));
  }
  zzk localzzk = this.zzapI;
  if (Looper.myLooper() == localzzk.mHandler.getLooper()) {}
  for (boolean bool = true;; bool = false)
  {
    zzx.zza(bool, "onUnintentionalDisconnection must only be called on the Handler thread");
    localzzk.mHandler.removeMessages(1);
    synchronized (localzzk.zzqp)
    {
      localzzk.zzauj = true;
      ArrayList localArrayList = new ArrayList(localzzk.zzaue);
      int i = localzzk.zzaui.get();
      Iterator localIterator2 = localArrayList.iterator();
      GoogleApiClient.ConnectionCallbacks localConnectionCallbacks;
      do
      {
        if (!localIterator2.hasNext()) {
          break;
        }
        localConnectionCallbacks = (GoogleApiClient.ConnectionCallbacks)localIterator2.next();
        if ((!localzzk.zzauh) || (localzzk.zzaui.get() != i)) {
          break;
        }
      } while (!localzzk.zzaue.contains(localConnectionCallbacks));
      localConnectionCallbacks.onConnectionSuspended(paramInt);
    }
  }
  localzzk.zzauf.clear();
  localzzk.zzauj = false;
  this.zzapI.zzqv();
  if (paramInt == 2) {
    zzpf();
  }
}

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);
}