package com.google.android.gms.common.api;

import android.accounts.Account;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.FragmentActivity;
import android.support.v4.util.ArrayMap;
import android.view.View;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.GoogleApiAvailability;
import com.google.android.gms.common.internal.zzac;
import com.google.android.gms.common.internal.zzg;
import com.google.android.gms.common.internal.zzg.zza;
import com.google.android.gms.internal.zzaaa;
import com.google.android.gms.internal.zzaad.zza;
import com.google.android.gms.internal.zzaag;
import com.google.android.gms.internal.zzaat;
import com.google.android.gms.internal.zzabd;
import com.google.android.gms.internal.zzabh;
import com.google.android.gms.internal.zzabq;
import com.google.android.gms.internal.zzabx;
import com.google.android.gms.internal.zzbah;
import com.google.android.gms.internal.zzbai;
import com.google.android.gms.internal.zzbaj;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public abstract class GoogleApiClient
{
  public static final int SIGN_IN_MODE_OPTIONAL = 2;
  public static final int SIGN_IN_MODE_REQUIRED = 1;
  private static final Set<GoogleApiClient> a = Collections.newSetFromMap(new WeakHashMap());
  
  public static void dumpAll(String paramString, FileDescriptor paramFileDescriptor, PrintWriter paramPrintWriter, String[] paramArrayOfString)
  {
    synchronized (a)
    {
      String str = String.valueOf(paramString).concat("  ");
      Iterator localIterator = a.iterator();
      int i = 0;
      while (localIterator.hasNext())
      {
        GoogleApiClient localGoogleApiClient = (GoogleApiClient)localIterator.next();
        paramPrintWriter.append(paramString).append("GoogleApiClient#").println(i);
        localGoogleApiClient.dump(str, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
        i += 1;
      }
      return;
    }
  }
  
  public static Set<GoogleApiClient> zzvm()
  {
    synchronized (a)
    {
      Set localSet2 = a;
      return localSet2;
    }
  }
  
  public abstract ConnectionResult blockingConnect();
  
  public abstract ConnectionResult blockingConnect(long paramLong, @NonNull TimeUnit paramTimeUnit);
  
  public abstract PendingResult<Status> clearDefaultAccountAndReconnect();
  
  public abstract void connect();
  
  public void connect(int paramInt)
  {
    throw new UnsupportedOperationException();
  }
  
  public abstract void disconnect();
  
  public abstract void dump(String paramString, FileDescriptor paramFileDescriptor, PrintWriter paramPrintWriter, String[] paramArrayOfString);
  
  @NonNull
  public abstract ConnectionResult getConnectionResult(@NonNull Api<?> paramApi);
  
  public Context getContext()
  {
    throw new UnsupportedOperationException();
  }
  
  public Looper getLooper()
  {
    throw new UnsupportedOperationException();
  }
  
  public abstract boolean hasConnectedApi(@NonNull Api<?> paramApi);
  
  public abstract boolean isConnected();
  
  public abstract boolean isConnecting();
  
  public abstract boolean isConnectionCallbacksRegistered(@NonNull ConnectionCallbacks paramConnectionCallbacks);
  
  public abstract boolean isConnectionFailedListenerRegistered(@NonNull OnConnectionFailedListener paramOnConnectionFailedListener);
  
  public abstract void reconnect();
  
  public abstract void registerConnectionCallbacks(@NonNull ConnectionCallbacks paramConnectionCallbacks);
  
  public abstract void registerConnectionFailedListener(@NonNull OnConnectionFailedListener paramOnConnectionFailedListener);
  
  public abstract void stopAutoManage(@NonNull FragmentActivity paramFragmentActivity);
  
  public abstract void unregisterConnectionCallbacks(@NonNull ConnectionCallbacks paramConnectionCallbacks);
  
  public abstract void unregisterConnectionFailedListener(@NonNull OnConnectionFailedListener paramOnConnectionFailedListener);
  
  @NonNull
  public <C extends Api.zze> C zza(@NonNull Api.zzc<C> paramzzc)
  {
    throw new UnsupportedOperationException();
  }
  
  public <A extends Api.zzb, R extends Result, T extends zzaad.zza<R, A>> T zza(@NonNull T paramT)
  {
    throw new UnsupportedOperationException();
  }
  
  public void zza(zzabx paramzzabx)
  {
    throw new UnsupportedOperationException();
  }
  
  public boolean zza(@NonNull Api<?> paramApi)
  {
    throw new UnsupportedOperationException();
  }
  
  public boolean zza(zzabq paramzzabq)
  {
    throw new UnsupportedOperationException();
  }
  
  public <A extends Api.zzb, T extends zzaad.zza<? extends Result, A>> T zzb(@NonNull T paramT)
  {
    throw new UnsupportedOperationException();
  }
  
  public void zzb(zzabx paramzzabx)
  {
    throw new UnsupportedOperationException();
  }
  
  public <L> zzabh<L> zzr(@NonNull L paramL)
  {
    throw new UnsupportedOperationException();
  }
  
  public void zzvn()
  {
    throw new UnsupportedOperationException();
  }
  
  public static final class Builder
  {
    private Account a;
    private final Set<Scope> b = new HashSet();
    private final Set<Scope> c = new HashSet();
    private int d;
    private View e;
    private String f;
    private String g;
    private final Map<Api<?>, zzg.zza> h = new ArrayMap();
    private final Context i;
    private final Map<Api<?>, Api.ApiOptions> j = new ArrayMap();
    private zzabd k;
    private int l = -1;
    private GoogleApiClient.OnConnectionFailedListener m;
    private Looper n;
    private GoogleApiAvailability o = GoogleApiAvailability.getInstance();
    private Api.zza<? extends zzbai, zzbaj> p = zzbah.zzaie;
    private final ArrayList<GoogleApiClient.ConnectionCallbacks> q = new ArrayList();
    private final ArrayList<GoogleApiClient.OnConnectionFailedListener> r = new ArrayList();
    private boolean s = false;
    
    public Builder(@NonNull Context paramContext)
    {
      this.i = paramContext;
      this.n = paramContext.getMainLooper();
      this.f = paramContext.getPackageName();
      this.g = paramContext.getClass().getName();
    }
    
    public Builder(@NonNull Context paramContext, @NonNull GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks, @NonNull GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
    {
      this(paramContext);
      zzac.zzb(paramConnectionCallbacks, "Must provide a connected listener");
      this.q.add(paramConnectionCallbacks);
      zzac.zzb(paramOnConnectionFailedListener, "Must provide a connection failed listener");
      this.r.add(paramOnConnectionFailedListener);
    }
    
    private <O extends Api.ApiOptions> void a(Api<O> paramApi, O paramO, Scope... paramVarArgs)
    {
      paramO = new HashSet(paramApi.zzve().zzp(paramO));
      int i2 = paramVarArgs.length;
      int i1 = 0;
      while (i1 < i2)
      {
        paramO.add(paramVarArgs[i1]);
        i1 += 1;
      }
      this.h.put(paramApi, new zzg.zza(paramO));
    }
    
    public final Builder addApi(@NonNull Api<? extends Api.ApiOptions.NotRequiredOptions> paramApi)
    {
      zzac.zzb(paramApi, "Api must not be null");
      this.j.put(paramApi, null);
      paramApi = paramApi.zzve().zzp(null);
      this.c.addAll(paramApi);
      this.b.addAll(paramApi);
      return this;
    }
    
    public final <O extends Api.ApiOptions.HasOptions> Builder addApi(@NonNull Api<O> paramApi, @NonNull O paramO)
    {
      zzac.zzb(paramApi, "Api must not be null");
      zzac.zzb(paramO, "Null options are not permitted for this Api");
      this.j.put(paramApi, paramO);
      paramApi = paramApi.zzve().zzp(paramO);
      this.c.addAll(paramApi);
      this.b.addAll(paramApi);
      return this;
    }
    
    public final <O extends Api.ApiOptions.HasOptions> Builder addApiIfAvailable(@NonNull Api<O> paramApi, @NonNull O paramO, Scope... paramVarArgs)
    {
      zzac.zzb(paramApi, "Api must not be null");
      zzac.zzb(paramO, "Null options are not permitted for this Api");
      this.j.put(paramApi, paramO);
      a(paramApi, paramO, paramVarArgs);
      return this;
    }
    
    public final Builder addApiIfAvailable(@NonNull Api<? extends Api.ApiOptions.NotRequiredOptions> paramApi, Scope... paramVarArgs)
    {
      zzac.zzb(paramApi, "Api must not be null");
      this.j.put(paramApi, null);
      a(paramApi, null, paramVarArgs);
      return this;
    }
    
    public final Builder addConnectionCallbacks(@NonNull GoogleApiClient.ConnectionCallbacks paramConnectionCallbacks)
    {
      zzac.zzb(paramConnectionCallbacks, "Listener must not be null");
      this.q.add(paramConnectionCallbacks);
      return this;
    }
    
    public final Builder addOnConnectionFailedListener(@NonNull GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
    {
      zzac.zzb(paramOnConnectionFailedListener, "Listener must not be null");
      this.r.add(paramOnConnectionFailedListener);
      return this;
    }
    
    public final Builder addScope(@NonNull Scope paramScope)
    {
      zzac.zzb(paramScope, "Scope must not be null");
      this.b.add(paramScope);
      return this;
    }
    
    public final GoogleApiClient build()
    {
      boolean bool;
      zzg localzzg;
      ArrayMap localArrayMap1;
      ArrayMap localArrayMap2;
      ArrayList localArrayList;
      int i1;
      label80:
      Api localApi;
      Object localObject2;
      label129:
      Object localObject4;
      if (!this.j.isEmpty())
      {
        bool = true;
        zzac.zzb(bool, "must call addApi() to add at least one API");
        localzzg = zzvp();
        ??? = null;
        Map localMap = localzzg.zzxN();
        localArrayMap1 = new ArrayMap();
        localArrayMap2 = new ArrayMap();
        localArrayList = new ArrayList();
        Iterator localIterator = this.j.keySet().iterator();
        i1 = 0;
        if (!localIterator.hasNext()) {
          break label336;
        }
        localApi = (Api)localIterator.next();
        localObject2 = this.j.get(localApi);
        if (localMap.get(localApi) == null) {
          break label317;
        }
        bool = true;
        localArrayMap1.put(localApi, Boolean.valueOf(bool));
        localObject4 = new zzaag(localApi, bool);
        localArrayList.add(localObject4);
        Api.zza localzza = localApi.zzvf();
        localObject4 = localzza.zza(this.i, this.n, localzzg, localObject2, (GoogleApiClient.ConnectionCallbacks)localObject4, (GoogleApiClient.OnConnectionFailedListener)localObject4);
        localArrayMap2.put(localApi.zzvg(), localObject4);
        if (localzza.getPriority() != 1) {
          break label580;
        }
        if (localObject2 == null) {
          break label322;
        }
        i1 = 1;
      }
      label317:
      label322:
      label330:
      label336:
      label568:
      label580:
      for (;;)
      {
        if (((Api.zze)localObject4).zzrr())
        {
          localObject2 = localApi;
          if (??? == null) {
            break label330;
          }
          localObject2 = String.valueOf(localApi.getName());
          ??? = String.valueOf(((Api)???).getName());
          throw new IllegalStateException(String.valueOf(localObject2).length() + 21 + String.valueOf(???).length() + (String)localObject2 + " cannot be used with " + (String)???);
          bool = false;
          break;
          bool = false;
          break label129;
          i1 = 0;
          continue;
        }
        localObject2 = ???;
        ??? = localObject2;
        break label80;
        if (??? != null)
        {
          if (i1 != 0)
          {
            ??? = String.valueOf(((Api)???).getName());
            throw new IllegalStateException(String.valueOf(???).length() + 82 + "With using " + (String)??? + ", GamesOptions can only be specified within GoogleSignInOptions.Builder");
          }
          if (this.a != null) {
            break label568;
          }
          bool = true;
        }
        for (;;)
        {
          zzac.zza(bool, "Must not set an account in GoogleApiClient.Builder when using %s. Set account in GoogleSignInOptions.Builder instead", new Object[] { ((Api)???).getName() });
          zzac.zza(this.b.equals(this.c), "Must not set scopes in GoogleApiClient.Builder when using %s. Set account in GoogleSignInOptions.Builder instead.", new Object[] { ((Api)???).getName() });
          i1 = zzaat.zza(localArrayMap2.values(), true);
          localObject2 = new zzaat(this.i, new ReentrantLock(), this.n, localzzg, this.o, this.p, localArrayMap1, this.q, this.r, localArrayMap2, this.l, i1, localArrayList, false);
          synchronized (GoogleApiClient.a())
          {
            GoogleApiClient.a().add(localObject2);
            if (this.l >= 0) {
              zzaaa.zza(this.k).zza(this.l, (GoogleApiClient)localObject2, this.m);
            }
            return (GoogleApiClient)localObject2;
            bool = false;
          }
        }
      }
    }
    
    public final Builder enableAutoManage(@NonNull FragmentActivity paramFragmentActivity, int paramInt, @Nullable GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
    {
      paramFragmentActivity = new zzabd(paramFragmentActivity);
      if (paramInt >= 0) {}
      for (boolean bool = true;; bool = false)
      {
        zzac.zzb(bool, "clientId must be non-negative");
        this.l = paramInt;
        this.m = paramOnConnectionFailedListener;
        this.k = paramFragmentActivity;
        return this;
      }
    }
    
    public final Builder enableAutoManage(@NonNull FragmentActivity paramFragmentActivity, @Nullable GoogleApiClient.OnConnectionFailedListener paramOnConnectionFailedListener)
    {
      return enableAutoManage(paramFragmentActivity, 0, paramOnConnectionFailedListener);
    }
    
    public final Builder setAccountName(String paramString)
    {
      if (paramString == null) {}
      for (paramString = null;; paramString = new Account(paramString, "com.google"))
      {
        this.a = paramString;
        return this;
      }
    }
    
    public final Builder setGravityForPopups(int paramInt)
    {
      this.d = paramInt;
      return this;
    }
    
    public final Builder setHandler(@NonNull Handler paramHandler)
    {
      zzac.zzb(paramHandler, "Handler must not be null");
      this.n = paramHandler.getLooper();
      return this;
    }
    
    public final Builder setViewForPopups(@NonNull View paramView)
    {
      zzac.zzb(paramView, "View must not be null");
      this.e = paramView;
      return this;
    }
    
    public final Builder useDefaultAccount()
    {
      return setAccountName("<<default account>>");
    }
    
    public final Builder zze(Account paramAccount)
    {
      this.a = paramAccount;
      return this;
    }
    
    public final zzg zzvp()
    {
      zzbaj localzzbaj = zzbaj.zzbEi;
      if (this.j.containsKey(zzbah.API)) {
        localzzbaj = (zzbaj)this.j.get(zzbah.API);
      }
      return new zzg(this.a, this.b, this.h, this.d, this.e, this.f, this.g, localzzbaj);
    }
  }
  
  public static abstract interface ConnectionCallbacks
  {
    public static final int CAUSE_NETWORK_LOST = 2;
    public static final int CAUSE_SERVICE_DISCONNECTED = 1;
    
    public abstract void onConnected(@Nullable Bundle paramBundle);
    
    public abstract void onConnectionSuspended(int paramInt);
  }
  
  public static abstract interface OnConnectionFailedListener
  {
    public abstract void onConnectionFailed(@NonNull ConnectionResult paramConnectionResult);
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/android/gms/common/api/GoogleApiClient.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */