Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/google/android/gms/common/api/internal/ActivityLifecycleObserver.java

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class ActivityLifecycleObserver {
+    @NonNull
+    @KeepForSdk
+    public static final ActivityLifecycleObserver of(@NonNull Activity activity) {
+        return new zab(zaa.zaa(activity));
+    }
+
+    @NonNull
+    @KeepForSdk
+    public abstract ActivityLifecycleObserver onStopCallOnce(@NonNull Runnable runnable);
+}

decompiled/sources/com/google/android/gms/common/api/internal/ApiExceptionMapper.java

@@ -0,0 +1,16 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.internal.ApiExceptionUtil;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class ApiExceptionMapper implements StatusExceptionMapper {
+    @Override // com.google.android.gms.common.api.internal.StatusExceptionMapper
+    @NonNull
+    public final Exception getException(@NonNull Status status) {
+        return ApiExceptionUtil.fromStatus(status);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/ApiKey.java

@@ -0,0 +1,57 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Api.ApiOptions;
+import com.google.android.gms.common.internal.Objects;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class ApiKey<O extends Api.ApiOptions> {
+    private final int zaa;
+    private final Api zab;
+
+    @Nullable
+    private final Api.ApiOptions zac;
+
+    @Nullable
+    private final String zad;
+
+    private ApiKey(Api api, @Nullable Api.ApiOptions apiOptions, @Nullable String str) {
+        this.zab = api;
+        this.zac = apiOptions;
+        this.zad = str;
+        this.zaa = Objects.hashCode(api, apiOptions, str);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <O extends Api.ApiOptions> ApiKey<O> getSharedApiKey(@NonNull Api<O> api, @Nullable O o, @Nullable String str) {
+        return new ApiKey<>(api, o, str);
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof ApiKey)) {
+            return false;
+        }
+        ApiKey apiKey = (ApiKey) obj;
+        return Objects.equal(this.zab, apiKey.zab) && Objects.equal(this.zac, apiKey.zac) && Objects.equal(this.zad, apiKey.zad);
+    }
+
+    public final int hashCode() {
+        return this.zaa;
+    }
+
+    @NonNull
+    public final String zaa() {
+        return this.zab.zad();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/BackgroundDetector.java

@@ -0,0 +1,155 @@
+package com.google.android.gms.common.api.internal;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.Application;
+import android.content.ComponentCallbacks2;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.util.PlatformVersion;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class BackgroundDetector implements Application.ActivityLifecycleCallbacks, ComponentCallbacks2 {
+    private static final BackgroundDetector zza = new BackgroundDetector();
+    private final AtomicBoolean zzb = new AtomicBoolean();
+    private final AtomicBoolean zzc = new AtomicBoolean();
+    private final ArrayList zzd = new ArrayList();
+    private boolean zze = false;
+
+    @KeepForSdk
+    public interface BackgroundStateChangeListener {
+        @KeepForSdk
+        void onBackgroundStateChanged(boolean z);
+    }
+
+    @KeepForSdk
+    private BackgroundDetector() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static BackgroundDetector getInstance() {
+        return zza;
+    }
+
+    @KeepForSdk
+    public static void initialize(@NonNull Application application) {
+        BackgroundDetector backgroundDetector = zza;
+        synchronized (backgroundDetector) {
+            try {
+                if (!backgroundDetector.zze) {
+                    application.registerActivityLifecycleCallbacks(backgroundDetector);
+                    application.registerComponentCallbacks(backgroundDetector);
+                    backgroundDetector.zze = true;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    private final void zza(boolean z) {
+        synchronized (zza) {
+            try {
+                Iterator it = this.zzd.iterator();
+                while (it.hasNext()) {
+                    ((BackgroundStateChangeListener) it.next()).onBackgroundStateChanged(z);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @KeepForSdk
+    public void addListener(@NonNull BackgroundStateChangeListener backgroundStateChangeListener) {
+        synchronized (zza) {
+            this.zzd.add(backgroundStateChangeListener);
+        }
+    }
+
+    @KeepForSdk
+    public boolean isInBackground() {
+        return this.zzb.get();
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityCreated(@NonNull Activity activity, @Nullable Bundle bundle) {
+        AtomicBoolean atomicBoolean = this.zzc;
+        boolean compareAndSet = this.zzb.compareAndSet(true, false);
+        atomicBoolean.set(true);
+        if (compareAndSet) {
+            zza(false);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityDestroyed(@NonNull Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityPaused(@NonNull Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityResumed(@NonNull Activity activity) {
+        AtomicBoolean atomicBoolean = this.zzc;
+        boolean compareAndSet = this.zzb.compareAndSet(true, false);
+        atomicBoolean.set(true);
+        if (compareAndSet) {
+            zza(false);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivitySaveInstanceState(@NonNull Activity activity, @NonNull Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityStarted(@NonNull Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityStopped(@NonNull Activity activity) {
+    }
+
+    @Override // android.content.ComponentCallbacks
+    public final void onConfigurationChanged(@NonNull Configuration configuration) {
+    }
+
+    @Override // android.content.ComponentCallbacks
+    public final void onLowMemory() {
+    }
+
+    @Override // android.content.ComponentCallbacks2
+    public final void onTrimMemory(int i) {
+        if (i == 20 && this.zzb.compareAndSet(false, true)) {
+            this.zzc.set(true);
+            zza(true);
+        }
+    }
+
+    @KeepForSdk
+    @TargetApi(16)
+    public boolean readCurrentStateIfPossible(boolean z) {
+        if (!this.zzc.get()) {
+            if (!PlatformVersion.isAtLeastJellyBean()) {
+                return z;
+            }
+            ActivityManager.RunningAppProcessInfo runningAppProcessInfo = new ActivityManager.RunningAppProcessInfo();
+            ActivityManager.getMyMemoryState(runningAppProcessInfo);
+            if (!this.zzc.getAndSet(true) && runningAppProcessInfo.importance > 100) {
+                this.zzb.set(true);
+            }
+        }
+        return isInBackground();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/BaseImplementation.java

@@ -0,0 +1,115 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.PendingIntent;
+import android.os.DeadObjectException;
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.BasePendingResult;
+import com.google.android.gms.common.internal.Preconditions;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class BaseImplementation {
+
+    @KeepForSdk
+    public interface ResultHolder<R> {
+        @KeepForSdk
+        void setFailedResult(@NonNull Status status);
+
+        @KeepForSdk
+        void setResult(@NonNull R r);
+    }
+
+    @KeepForSdk
+    public static abstract class ApiMethodImpl<R extends Result, A extends Api.AnyClient> extends BasePendingResult<R> implements ResultHolder<R> {
+
+        @Nullable
+        @KeepForSdk
+        private final Api<?> api;
+
+        @KeepForSdk
+        private final Api.AnyClientKey<A> clientKey;
+
+        @KeepForSdk
+        @Deprecated
+        public ApiMethodImpl(@NonNull Api.AnyClientKey<A> anyClientKey, @NonNull GoogleApiClient googleApiClient) {
+            super((GoogleApiClient) Preconditions.checkNotNull(googleApiClient, "GoogleApiClient must not be null"));
+            this.clientKey = (Api.AnyClientKey) Preconditions.checkNotNull(anyClientKey);
+            this.api = null;
+        }
+
+        @KeepForSdk
+        private void setFailedResult(@NonNull RemoteException remoteException) {
+            setFailedResult(new Status(8, remoteException.getLocalizedMessage(), (PendingIntent) null));
+        }
+
+        @KeepForSdk
+        public abstract void doExecute(@NonNull A a) throws RemoteException;
+
+        @Nullable
+        @KeepForSdk
+        public final Api<?> getApi() {
+            return this.api;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public final Api.AnyClientKey<A> getClientKey() {
+            return this.clientKey;
+        }
+
+        @KeepForSdk
+        public void onSetFailedResult(@NonNull R r) {
+        }
+
+        @KeepForSdk
+        public final void run(@NonNull A a) throws DeadObjectException {
+            try {
+                doExecute(a);
+            } catch (DeadObjectException e) {
+                setFailedResult(e);
+                throw e;
+            } catch (RemoteException e2) {
+                setFailedResult(e2);
+            }
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @KeepForSdk
+        public /* bridge */ /* synthetic */ void setResult(@NonNull Object obj) {
+            super.setResult((ApiMethodImpl<R, A>) obj);
+        }
+
+        @KeepForSdk
+        public ApiMethodImpl(@NonNull Api<?> api, @NonNull GoogleApiClient googleApiClient) {
+            super((GoogleApiClient) Preconditions.checkNotNull(googleApiClient, "GoogleApiClient must not be null"));
+            Preconditions.checkNotNull(api, "Api must not be null");
+            this.clientKey = api.zab();
+            this.api = api;
+        }
+
+        @Override // com.google.android.gms.common.api.internal.BaseImplementation.ResultHolder
+        @KeepForSdk
+        public final void setFailedResult(@NonNull Status status) {
+            Preconditions.checkArgument(!status.isSuccess(), "Failed result must not be success");
+            R createFailedResult = createFailedResult(status);
+            setResult((ApiMethodImpl<R, A>) createFailedResult);
+            onSetFailedResult(createFailedResult);
+        }
+
+        @KeepForSdk
+        @VisibleForTesting
+        public ApiMethodImpl(@NonNull BasePendingResult.CallbackHandler<R> callbackHandler) {
+            super(callbackHandler);
+            this.clientKey = new Api.AnyClientKey<>();
+            this.api = null;
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/BasePendingResult.java

@@ -0,0 +1,445 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import android.os.Message;
+import android.os.RemoteException;
+import android.util.Log;
+import android.util.Pair;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.annotation.KeepName;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Releasable;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultCallback;
+import com.google.android.gms.common.api.ResultTransform;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.TransformedResult;
+import com.google.android.gms.common.internal.ICancelToken;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+@KeepForSdk
+@KeepName
+/* loaded from: classes2.dex */
+public abstract class BasePendingResult<R extends Result> extends PendingResult<R> {
+    static final ThreadLocal zaa = new zaq();
+    public static final /* synthetic */ int zad = 0;
+
+    @KeepName
+    private zas resultGuardian;
+
+    @NonNull
+    protected final CallbackHandler zab;
+
+    @NonNull
+    protected final WeakReference zac;
+    private final Object zae;
+    private final CountDownLatch zaf;
+    private final ArrayList zag;
+
+    @Nullable
+    private ResultCallback zah;
+    private final AtomicReference zai;
+
+    @Nullable
+    private Result zaj;
+    private Status zak;
+    private volatile boolean zal;
+    private boolean zam;
+    private boolean zan;
+
+    @Nullable
+    private ICancelToken zao;
+    private volatile zada zap;
+    private boolean zaq;
+
+    @Deprecated
+    public BasePendingResult() {
+        this.zae = new Object();
+        this.zaf = new CountDownLatch(1);
+        this.zag = new ArrayList();
+        this.zai = new AtomicReference();
+        this.zaq = false;
+        this.zab = new CallbackHandler(Looper.getMainLooper());
+        this.zac = new WeakReference(null);
+    }
+
+    private final Result zaa() {
+        Result result;
+        synchronized (this.zae) {
+            Preconditions.checkState(!this.zal, "Result has already been consumed.");
+            Preconditions.checkState(isReady(), "Result is not ready.");
+            result = this.zaj;
+            this.zaj = null;
+            this.zah = null;
+            this.zal = true;
+        }
+        zadb zadbVar = (zadb) this.zai.getAndSet(null);
+        if (zadbVar != null) {
+            zadbVar.zaa.zab.remove(this);
+        }
+        return (Result) Preconditions.checkNotNull(result);
+    }
+
+    private final void zab(Result result) {
+        this.zaj = result;
+        this.zak = result.getStatus();
+        zar zarVar = null;
+        this.zao = null;
+        this.zaf.countDown();
+        if (this.zam) {
+            this.zah = null;
+        } else {
+            ResultCallback resultCallback = this.zah;
+            if (resultCallback != null) {
+                this.zab.removeMessages(2);
+                this.zab.zaa(resultCallback, zaa());
+            } else if (this.zaj instanceof Releasable) {
+                this.resultGuardian = new zas(this, zarVar);
+            }
+        }
+        ArrayList arrayList = this.zag;
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            ((PendingResult.StatusListener) arrayList.get(i)).onComplete(this.zak);
+        }
+        this.zag.clear();
+    }
+
+    public static void zal(@Nullable Result result) {
+        if (result instanceof Releasable) {
+            try {
+                ((Releasable) result).release();
+            } catch (RuntimeException e) {
+                Log.w("BasePendingResult", "Unable to release ".concat(String.valueOf(result)), e);
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void addStatusListener(@NonNull PendingResult.StatusListener statusListener) {
+        Preconditions.checkArgument(statusListener != null, "Callback cannot be null.");
+        synchronized (this.zae) {
+            try {
+                if (isReady()) {
+                    statusListener.onComplete(this.zak);
+                } else {
+                    this.zag.add(statusListener);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public final R await() {
+        Preconditions.checkNotMainThread("await must not be called on the UI thread");
+        Preconditions.checkState(!this.zal, "Result has already been consumed");
+        Preconditions.checkState(this.zap == null, "Cannot await if then() has been called.");
+        try {
+            this.zaf.await();
+        } catch (InterruptedException unused) {
+            forceFailureUnlessReady(Status.RESULT_INTERRUPTED);
+        }
+        Preconditions.checkState(isReady(), "Result is not ready.");
+        return (R) zaa();
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @KeepForSdk
+    public void cancel() {
+        synchronized (this.zae) {
+            if (!this.zam && !this.zal) {
+                ICancelToken iCancelToken = this.zao;
+                if (iCancelToken != null) {
+                    try {
+                        iCancelToken.cancel();
+                    } catch (RemoteException unused) {
+                    }
+                }
+                zal(this.zaj);
+                this.zam = true;
+                zab(createFailedResult(Status.RESULT_CANCELED));
+            }
+        }
+    }
+
+    @NonNull
+    @KeepForSdk
+    public abstract R createFailedResult(@NonNull Status status);
+
+    @KeepForSdk
+    @Deprecated
+    public final void forceFailureUnlessReady(@NonNull Status status) {
+        synchronized (this.zae) {
+            try {
+                if (!isReady()) {
+                    setResult(createFailedResult(status));
+                    this.zan = true;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final boolean isCanceled() {
+        boolean z;
+        synchronized (this.zae) {
+            z = this.zam;
+        }
+        return z;
+    }
+
+    @KeepForSdk
+    public final boolean isReady() {
+        return this.zaf.getCount() == 0;
+    }
+
+    @KeepForSdk
+    public final void setCancelToken(@NonNull ICancelToken iCancelToken) {
+        synchronized (this.zae) {
+            this.zao = iCancelToken;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @KeepForSdk
+    public final void setResultCallback(@Nullable ResultCallback<? super R> resultCallback) {
+        synchronized (this.zae) {
+            try {
+                if (resultCallback == null) {
+                    this.zah = null;
+                    return;
+                }
+                boolean z = true;
+                Preconditions.checkState(!this.zal, "Result has already been consumed.");
+                if (this.zap != null) {
+                    z = false;
+                }
+                Preconditions.checkState(z, "Cannot set callbacks if then() has been called.");
+                if (isCanceled()) {
+                    return;
+                }
+                if (isReady()) {
+                    this.zab.zaa(resultCallback, zaa());
+                } else {
+                    this.zah = resultCallback;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final <S extends Result> TransformedResult<S> then(@NonNull ResultTransform<? super R, ? extends S> resultTransform) {
+        TransformedResult<S> then;
+        Preconditions.checkState(!this.zal, "Result has already been consumed.");
+        synchronized (this.zae) {
+            try {
+                Preconditions.checkState(this.zap == null, "Cannot call then() twice.");
+                Preconditions.checkState(this.zah == null, "Cannot call then() if callbacks are set.");
+                Preconditions.checkState(!this.zam, "Cannot call then() if result was canceled.");
+                this.zaq = true;
+                this.zap = new zada(this.zac);
+                then = this.zap.then(resultTransform);
+                if (isReady()) {
+                    this.zab.zaa(this.zap, zaa());
+                } else {
+                    this.zah = this.zap;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return then;
+    }
+
+    public final void zak() {
+        boolean z = true;
+        if (!this.zaq && !((Boolean) zaa.get()).booleanValue()) {
+            z = false;
+        }
+        this.zaq = z;
+    }
+
+    public final boolean zam() {
+        boolean isCanceled;
+        synchronized (this.zae) {
+            try {
+                if (((GoogleApiClient) this.zac.get()) != null) {
+                    if (!this.zaq) {
+                    }
+                    isCanceled = isCanceled();
+                }
+                cancel();
+                isCanceled = isCanceled();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return isCanceled;
+    }
+
+    public final void zan(@Nullable zadb zadbVar) {
+        this.zai.set(zadbVar);
+    }
+
+    @VisibleForTesting
+    public static class CallbackHandler<R extends Result> extends com.google.android.gms.internal.base.zau {
+        public CallbackHandler() {
+            super(Looper.getMainLooper());
+        }
+
+        /* JADX WARN: Multi-variable type inference failed */
+        @Override // android.os.Handler
+        public final void handleMessage(@NonNull Message message) {
+            int i = message.what;
+            if (i != 1) {
+                if (i == 2) {
+                    ((BasePendingResult) message.obj).forceFailureUnlessReady(Status.RESULT_TIMEOUT);
+                    return;
+                }
+                Log.wtf("BasePendingResult", "Don't know how to handle message: " + i, new Exception());
+                return;
+            }
+            Pair pair = (Pair) message.obj;
+            ResultCallback resultCallback = (ResultCallback) pair.first;
+            Result result = (Result) pair.second;
+            try {
+                resultCallback.onResult(result);
+            } catch (RuntimeException e) {
+                BasePendingResult.zal(result);
+                throw e;
+            }
+        }
+
+        public final void zaa(@NonNull ResultCallback resultCallback, @NonNull Result result) {
+            int i = BasePendingResult.zad;
+            sendMessage(obtainMessage(1, new Pair((ResultCallback) Preconditions.checkNotNull(resultCallback), result)));
+        }
+
+        public CallbackHandler(@NonNull Looper looper) {
+            super(looper);
+        }
+    }
+
+    @KeepForSdk
+    public final void setResult(@NonNull R r) {
+        synchronized (this.zae) {
+            try {
+                if (this.zan || this.zam) {
+                    zal(r);
+                    return;
+                }
+                isReady();
+                Preconditions.checkState(!isReady(), "Results have already been set");
+                Preconditions.checkState(!this.zal, "Result has already been consumed");
+                zab(r);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public BasePendingResult(@NonNull Looper looper) {
+        this.zae = new Object();
+        this.zaf = new CountDownLatch(1);
+        this.zag = new ArrayList();
+        this.zai = new AtomicReference();
+        this.zaq = false;
+        this.zab = new CallbackHandler(looper);
+        this.zac = new WeakReference(null);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public final R await(long j, @NonNull TimeUnit timeUnit) {
+        if (j > 0) {
+            Preconditions.checkNotMainThread("await must not be called on the UI thread when time is greater than zero.");
+        }
+        Preconditions.checkState(!this.zal, "Result has already been consumed.");
+        Preconditions.checkState(this.zap == null, "Cannot await if then() has been called.");
+        try {
+            if (!this.zaf.await(j, timeUnit)) {
+                forceFailureUnlessReady(Status.RESULT_TIMEOUT);
+            }
+        } catch (InterruptedException unused) {
+            forceFailureUnlessReady(Status.RESULT_INTERRUPTED);
+        }
+        Preconditions.checkState(isReady(), "Result is not ready.");
+        return (R) zaa();
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @KeepForSdk
+    public final void setResultCallback(@NonNull ResultCallback<? super R> resultCallback, long j, @NonNull TimeUnit timeUnit) {
+        synchronized (this.zae) {
+            try {
+                if (resultCallback == null) {
+                    this.zah = null;
+                    return;
+                }
+                boolean z = true;
+                Preconditions.checkState(!this.zal, "Result has already been consumed.");
+                if (this.zap != null) {
+                    z = false;
+                }
+                Preconditions.checkState(z, "Cannot set callbacks if then() has been called.");
+                if (isCanceled()) {
+                    return;
+                }
+                if (!isReady()) {
+                    this.zah = resultCallback;
+                    CallbackHandler callbackHandler = this.zab;
+                    callbackHandler.sendMessageDelayed(callbackHandler.obtainMessage(2, this), timeUnit.toMillis(j));
+                } else {
+                    this.zab.zaa(resultCallback, zaa());
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @KeepForSdk
+    public BasePendingResult(@Nullable GoogleApiClient googleApiClient) {
+        this.zae = new Object();
+        this.zaf = new CountDownLatch(1);
+        this.zag = new ArrayList();
+        this.zai = new AtomicReference();
+        this.zaq = false;
+        this.zab = new CallbackHandler(googleApiClient != null ? googleApiClient.getLooper() : Looper.getMainLooper());
+        this.zac = new WeakReference(googleApiClient);
+    }
+
+    @KeepForSdk
+    @VisibleForTesting
+    public BasePendingResult(@NonNull CallbackHandler<R> callbackHandler) {
+        this.zae = new Object();
+        this.zaf = new CountDownLatch(1);
+        this.zag = new ArrayList();
+        this.zai = new AtomicReference();
+        this.zaq = false;
+        this.zab = (CallbackHandler) Preconditions.checkNotNull(callbackHandler, "CallbackHandler must not be null");
+        this.zac = new WeakReference(null);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/ConnectionCallbacks.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface ConnectionCallbacks {
+    @ShowFirstParty
+    @KeepForSdk
+    void onConnected(@Nullable Bundle bundle);
+
+    @ShowFirstParty
+    @KeepForSdk
+    void onConnectionSuspended(int i);
+}

decompiled/sources/com/google/android/gms/common/api/internal/DataHolderNotifier.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.data.DataHolder;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class DataHolderNotifier<L> implements ListenerHolder.Notifier<L> {
+    private final DataHolder zaa;
+
+    @KeepForSdk
+    public DataHolderNotifier(@NonNull DataHolder dataHolder) {
+        this.zaa = dataHolder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ListenerHolder.Notifier
+    @KeepForSdk
+    public final void notifyListener(@NonNull L l) {
+        notifyListener(l, this.zaa);
+    }
+
+    @KeepForSdk
+    public abstract void notifyListener(@NonNull L l, @NonNull DataHolder dataHolder);
+
+    @Override // com.google.android.gms.common.api.internal.ListenerHolder.Notifier
+    @KeepForSdk
+    public void onNotifyListenerFailed() {
+        DataHolder dataHolder = this.zaa;
+        if (dataHolder != null) {
+            dataHolder.close();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/DataHolderResult.java

@@ -0,0 +1,48 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Releasable;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.data.DataHolder;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class DataHolderResult implements Result, Releasable {
+
+    @NonNull
+    @KeepForSdk
+    protected final DataHolder mDataHolder;
+
+    @NonNull
+    @KeepForSdk
+    protected final Status mStatus;
+
+    @KeepForSdk
+    public DataHolderResult(@NonNull DataHolder dataHolder) {
+        this(dataHolder, new Status(dataHolder.getStatusCode()));
+    }
+
+    @KeepForSdk
+    public DataHolderResult(@NonNull DataHolder dataHolder, @NonNull Status status) {
+        this.mStatus = status;
+        this.mDataHolder = dataHolder;
+    }
+
+    @Override // com.google.android.gms.common.api.Result
+    @NonNull
+    @KeepForSdk
+    public Status getStatus() {
+        return this.mStatus;
+    }
+
+    @Override // com.google.android.gms.common.api.Releasable
+    @KeepForSdk
+    public void release() {
+        DataHolder dataHolder = this.mDataHolder;
+        if (dataHolder != null) {
+            dataHolder.close();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/GoogleApiManager.java

@@ -0,0 +1,500 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Application;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+import androidx.collection.ArraySet;
+import androidx.work.PeriodicWorkRequest;
+import androidx.work.WorkRequest;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.GoogleApi;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.internal.GmsClientSupervisor;
+import com.google.android.gms.common.internal.MethodInvocation;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.RootTelemetryConfigManager;
+import com.google.android.gms.common.internal.RootTelemetryConfiguration;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.TelemetryData;
+import com.google.android.gms.common.internal.TelemetryLogging;
+import com.google.android.gms.common.internal.TelemetryLoggingClient;
+import com.google.android.gms.common.util.DeviceProperties;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class GoogleApiManager implements Handler.Callback {
+
+    @NonNull
+    public static final Status zaa = new Status(4, "Sign-out occurred while this API call was in progress.");
+    private static final Status zab = new Status(4, "The user must be signed in to make this API call.");
+    private static final Object zac = new Object();
+
+    @Nullable
+    private static GoogleApiManager zad;
+
+    @Nullable
+    private TelemetryData zag;
+
+    @Nullable
+    private TelemetryLoggingClient zah;
+    private final Context zai;
+    private final GoogleApiAvailability zaj;
+    private final com.google.android.gms.common.internal.zal zak;
+    private final Handler zar;
+    private volatile boolean zas;
+    private long zae = WorkRequest.MIN_BACKOFF_MILLIS;
+    private boolean zaf = false;
+    private final AtomicInteger zal = new AtomicInteger(1);
+    private final AtomicInteger zam = new AtomicInteger(0);
+    private final Map zan = new ConcurrentHashMap(5, 0.75f, 1);
+
+    @Nullable
+    private zaae zao = null;
+    private final Set zap = new ArraySet();
+    private final Set zaq = new ArraySet();
+
+    @KeepForSdk
+    private GoogleApiManager(Context context, Looper looper, GoogleApiAvailability googleApiAvailability) {
+        this.zas = true;
+        this.zai = context;
+        com.google.android.gms.internal.base.zau zauVar = new com.google.android.gms.internal.base.zau(looper, this);
+        this.zar = zauVar;
+        this.zaj = googleApiAvailability;
+        this.zak = new com.google.android.gms.common.internal.zal(googleApiAvailability);
+        if (DeviceProperties.isAuto(context)) {
+            this.zas = false;
+        }
+        zauVar.sendMessage(zauVar.obtainMessage(6));
+    }
+
+    @KeepForSdk
+    public static void reportSignOut() {
+        synchronized (zac) {
+            try {
+                GoogleApiManager googleApiManager = zad;
+                if (googleApiManager != null) {
+                    googleApiManager.zam.incrementAndGet();
+                    Handler handler = googleApiManager.zar;
+                    handler.sendMessageAtFrontOfQueue(handler.obtainMessage(10));
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static Status zaF(ApiKey apiKey, ConnectionResult connectionResult) {
+        return new Status(connectionResult, "API: " + apiKey.zaa() + " is not available on this device. Connection failed with: " + String.valueOf(connectionResult));
+    }
+
+    @ResultIgnorabilityUnspecified
+    @WorkerThread
+    private final zabq zaG(GoogleApi googleApi) {
+        Map map = this.zan;
+        ApiKey apiKey = googleApi.getApiKey();
+        zabq zabqVar = (zabq) map.get(apiKey);
+        if (zabqVar == null) {
+            zabqVar = new zabq(this, googleApi);
+            this.zan.put(apiKey, zabqVar);
+        }
+        if (zabqVar.zaA()) {
+            this.zaq.add(apiKey);
+        }
+        zabqVar.zao();
+        return zabqVar;
+    }
+
+    @WorkerThread
+    private final TelemetryLoggingClient zaH() {
+        if (this.zah == null) {
+            this.zah = TelemetryLogging.getClient(this.zai);
+        }
+        return this.zah;
+    }
+
+    @WorkerThread
+    private final void zaI() {
+        TelemetryData telemetryData = this.zag;
+        if (telemetryData != null) {
+            if (telemetryData.zaa() > 0 || zaD()) {
+                zaH().log(telemetryData);
+            }
+            this.zag = null;
+        }
+    }
+
+    private final void zaJ(TaskCompletionSource taskCompletionSource, int i, GoogleApi googleApi) {
+        zacd zaa2;
+        if (i == 0 || (zaa2 = zacd.zaa(this, i, googleApi.getApiKey())) == null) {
+            return;
+        }
+        Task task = taskCompletionSource.getTask();
+        final Handler handler = this.zar;
+        handler.getClass();
+        task.addOnCompleteListener(new Executor() { // from class: com.google.android.gms.common.api.internal.zabk
+            @Override // java.util.concurrent.Executor
+            public final void execute(Runnable runnable) {
+                handler.post(runnable);
+            }
+        }, zaa2);
+    }
+
+    @NonNull
+    public static GoogleApiManager zaj() {
+        GoogleApiManager googleApiManager;
+        synchronized (zac) {
+            Preconditions.checkNotNull(zad, "Must guarantee manager is non-null before using getInstance");
+            googleApiManager = zad;
+        }
+        return googleApiManager;
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public static GoogleApiManager zak(@NonNull Context context) {
+        GoogleApiManager googleApiManager;
+        synchronized (zac) {
+            try {
+                if (zad == null) {
+                    zad = new GoogleApiManager(context.getApplicationContext(), GmsClientSupervisor.getOrStartHandlerThread().getLooper(), GoogleApiAvailability.getInstance());
+                }
+                googleApiManager = zad;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return googleApiManager;
+    }
+
+    @Override // android.os.Handler.Callback
+    @WorkerThread
+    public final boolean handleMessage(@NonNull Message message) {
+        ApiKey apiKey;
+        boolean zaO;
+        ApiKey apiKey2;
+        ApiKey apiKey3;
+        ApiKey apiKey4;
+        ApiKey apiKey5;
+        int i = message.what;
+        long j = PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS;
+        zabq zabqVar = null;
+        switch (i) {
+            case 1:
+                if (true == ((Boolean) message.obj).booleanValue()) {
+                    j = WorkRequest.MIN_BACKOFF_MILLIS;
+                }
+                this.zae = j;
+                this.zar.removeMessages(12);
+                for (ApiKey apiKey6 : this.zan.keySet()) {
+                    Handler handler = this.zar;
+                    handler.sendMessageDelayed(handler.obtainMessage(12, apiKey6), this.zae);
+                }
+                return true;
+            case 2:
+                zal zalVar = (zal) message.obj;
+                Iterator it = zalVar.zab().iterator();
+                while (true) {
+                    if (it.hasNext()) {
+                        ApiKey apiKey7 = (ApiKey) it.next();
+                        zabq zabqVar2 = (zabq) this.zan.get(apiKey7);
+                        if (zabqVar2 == null) {
+                            zalVar.zac(apiKey7, new ConnectionResult(13), null);
+                        } else if (zabqVar2.zaz()) {
+                            zalVar.zac(apiKey7, ConnectionResult.RESULT_SUCCESS, zabqVar2.zaf().getEndpointPackageName());
+                        } else {
+                            ConnectionResult zad2 = zabqVar2.zad();
+                            if (zad2 != null) {
+                                zalVar.zac(apiKey7, zad2, null);
+                            } else {
+                                zabqVar2.zat(zalVar);
+                                zabqVar2.zao();
+                            }
+                        }
+                    }
+                }
+                return true;
+            case 3:
+                for (zabq zabqVar3 : this.zan.values()) {
+                    zabqVar3.zan();
+                    zabqVar3.zao();
+                }
+                return true;
+            case 4:
+            case 8:
+            case 13:
+                zach zachVar = (zach) message.obj;
+                zabq zabqVar4 = (zabq) this.zan.get(zachVar.zac.getApiKey());
+                if (zabqVar4 == null) {
+                    zabqVar4 = zaG(zachVar.zac);
+                }
+                if (!zabqVar4.zaA() || this.zam.get() == zachVar.zab) {
+                    zabqVar4.zap(zachVar.zaa);
+                } else {
+                    zachVar.zaa.zad(zaa);
+                    zabqVar4.zav();
+                }
+                return true;
+            case 5:
+                int i2 = message.arg1;
+                ConnectionResult connectionResult = (ConnectionResult) message.obj;
+                Iterator it2 = this.zan.values().iterator();
+                while (true) {
+                    if (it2.hasNext()) {
+                        zabq zabqVar5 = (zabq) it2.next();
+                        if (zabqVar5.zab() == i2) {
+                            zabqVar = zabqVar5;
+                        }
+                    }
+                }
+                if (zabqVar == null) {
+                    Log.wtf("GoogleApiManager", "Could not find API instance " + i2 + " while trying to fail enqueued calls.", new Exception());
+                } else if (connectionResult.getErrorCode() == 13) {
+                    zabqVar.zaE(new Status(17, "Error resolution was canceled by the user, original error message: " + this.zaj.getErrorString(connectionResult.getErrorCode()) + ": " + connectionResult.getErrorMessage()));
+                } else {
+                    apiKey = zabqVar.zad;
+                    zabqVar.zaE(zaF(apiKey, connectionResult));
+                }
+                return true;
+            case 6:
+                if (this.zai.getApplicationContext() instanceof Application) {
+                    BackgroundDetector.initialize((Application) this.zai.getApplicationContext());
+                    BackgroundDetector.getInstance().addListener(new zabl(this));
+                    if (!BackgroundDetector.getInstance().readCurrentStateIfPossible(true)) {
+                        this.zae = PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS;
+                    }
+                }
+                return true;
+            case 7:
+                zaG((GoogleApi) message.obj);
+                return true;
+            case 9:
+                if (this.zan.containsKey(message.obj)) {
+                    ((zabq) this.zan.get(message.obj)).zau();
+                }
+                return true;
+            case 10:
+                Iterator it3 = this.zaq.iterator();
+                while (it3.hasNext()) {
+                    zabq zabqVar6 = (zabq) this.zan.remove((ApiKey) it3.next());
+                    if (zabqVar6 != null) {
+                        zabqVar6.zav();
+                    }
+                }
+                this.zaq.clear();
+                return true;
+            case 11:
+                if (this.zan.containsKey(message.obj)) {
+                    ((zabq) this.zan.get(message.obj)).zaw();
+                }
+                return true;
+            case 12:
+                if (this.zan.containsKey(message.obj)) {
+                    ((zabq) this.zan.get(message.obj)).zaB();
+                }
+                return true;
+            case 14:
+                zaaf zaafVar = (zaaf) message.obj;
+                ApiKey zaa2 = zaafVar.zaa();
+                if (this.zan.containsKey(zaa2)) {
+                    zaO = ((zabq) this.zan.get(zaa2)).zaO(false);
+                    zaafVar.zab().setResult(Boolean.valueOf(zaO));
+                } else {
+                    zaafVar.zab().setResult(Boolean.FALSE);
+                }
+                return true;
+            case 15:
+                zabs zabsVar = (zabs) message.obj;
+                Map map = this.zan;
+                apiKey2 = zabsVar.zaa;
+                if (map.containsKey(apiKey2)) {
+                    Map map2 = this.zan;
+                    apiKey3 = zabsVar.zaa;
+                    zabq.zal((zabq) map2.get(apiKey3), zabsVar);
+                }
+                return true;
+            case 16:
+                zabs zabsVar2 = (zabs) message.obj;
+                Map map3 = this.zan;
+                apiKey4 = zabsVar2.zaa;
+                if (map3.containsKey(apiKey4)) {
+                    Map map4 = this.zan;
+                    apiKey5 = zabsVar2.zaa;
+                    zabq.zam((zabq) map4.get(apiKey5), zabsVar2);
+                }
+                return true;
+            case 17:
+                zaI();
+                return true;
+            case 18:
+                zace zaceVar = (zace) message.obj;
+                if (zaceVar.zac == 0) {
+                    zaH().log(new TelemetryData(zaceVar.zab, Arrays.asList(zaceVar.zaa)));
+                } else {
+                    TelemetryData telemetryData = this.zag;
+                    if (telemetryData != null) {
+                        List zab2 = telemetryData.zab();
+                        if (telemetryData.zaa() != zaceVar.zab || (zab2 != null && zab2.size() >= zaceVar.zad)) {
+                            this.zar.removeMessages(17);
+                            zaI();
+                        } else {
+                            this.zag.zac(zaceVar.zaa);
+                        }
+                    }
+                    if (this.zag == null) {
+                        ArrayList arrayList = new ArrayList();
+                        arrayList.add(zaceVar.zaa);
+                        this.zag = new TelemetryData(zaceVar.zab, arrayList);
+                        Handler handler2 = this.zar;
+                        handler2.sendMessageDelayed(handler2.obtainMessage(17), zaceVar.zac);
+                    }
+                }
+                return true;
+            case 19:
+                this.zaf = false;
+                return true;
+            default:
+                Log.w("GoogleApiManager", "Unknown message id: " + i);
+                return false;
+        }
+    }
+
+    public final void zaA(@NonNull zaae zaaeVar) {
+        synchronized (zac) {
+            try {
+                if (this.zao != zaaeVar) {
+                    this.zao = zaaeVar;
+                    this.zap.clear();
+                }
+                this.zap.addAll(zaaeVar.zaa());
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void zaB(@NonNull zaae zaaeVar) {
+        synchronized (zac) {
+            try {
+                if (this.zao == zaaeVar) {
+                    this.zao = null;
+                    this.zap.clear();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @WorkerThread
+    public final boolean zaD() {
+        if (this.zaf) {
+            return false;
+        }
+        RootTelemetryConfiguration config = RootTelemetryConfigManager.getInstance().getConfig();
+        if (config != null && !config.getMethodInvocationTelemetryEnabled()) {
+            return false;
+        }
+        int zaa2 = this.zak.zaa(this.zai, 203400000);
+        return zaa2 == -1 || zaa2 == 0;
+    }
+
+    @ResultIgnorabilityUnspecified
+    public final boolean zaE(ConnectionResult connectionResult, int i) {
+        return this.zaj.zah(this.zai, connectionResult, i);
+    }
+
+    public final int zaa() {
+        return this.zal.getAndIncrement();
+    }
+
+    @Nullable
+    public final zabq zai(ApiKey apiKey) {
+        return (zabq) this.zan.get(apiKey);
+    }
+
+    @NonNull
+    public final Task zam(@NonNull Iterable iterable) {
+        zal zalVar = new zal(iterable);
+        this.zar.sendMessage(this.zar.obtainMessage(2, zalVar));
+        return zalVar.zaa();
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public final Task zan(@NonNull GoogleApi googleApi) {
+        zaaf zaafVar = new zaaf(googleApi.getApiKey());
+        this.zar.sendMessage(this.zar.obtainMessage(14, zaafVar));
+        return zaafVar.zab().getTask();
+    }
+
+    @NonNull
+    public final Task zao(@NonNull GoogleApi googleApi, @NonNull RegisterListenerMethod registerListenerMethod, @NonNull UnregisterListenerMethod unregisterListenerMethod, @NonNull Runnable runnable) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        zaJ(taskCompletionSource, registerListenerMethod.zaa(), googleApi);
+        this.zar.sendMessage(this.zar.obtainMessage(8, new zach(new zaf(new zaci(registerListenerMethod, unregisterListenerMethod, runnable), taskCompletionSource), this.zam.get(), googleApi)));
+        return taskCompletionSource.getTask();
+    }
+
+    @NonNull
+    public final Task zap(@NonNull GoogleApi googleApi, @NonNull ListenerHolder.ListenerKey listenerKey, int i) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        zaJ(taskCompletionSource, i, googleApi);
+        this.zar.sendMessage(this.zar.obtainMessage(13, new zach(new zah(listenerKey, taskCompletionSource), this.zam.get(), googleApi)));
+        return taskCompletionSource.getTask();
+    }
+
+    public final void zau(@NonNull GoogleApi googleApi, int i, @NonNull BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        this.zar.sendMessage(this.zar.obtainMessage(4, new zach(new zae(i, apiMethodImpl), this.zam.get(), googleApi)));
+    }
+
+    public final void zav(@NonNull GoogleApi googleApi, int i, @NonNull TaskApiCall taskApiCall, @NonNull TaskCompletionSource taskCompletionSource, @NonNull StatusExceptionMapper statusExceptionMapper) {
+        zaJ(taskCompletionSource, taskApiCall.zaa(), googleApi);
+        this.zar.sendMessage(this.zar.obtainMessage(4, new zach(new zag(i, taskApiCall, taskCompletionSource, statusExceptionMapper), this.zam.get(), googleApi)));
+    }
+
+    public final void zaw(MethodInvocation methodInvocation, int i, long j, int i2) {
+        this.zar.sendMessage(this.zar.obtainMessage(18, new zace(methodInvocation, i, j, i2)));
+    }
+
+    public final void zax(@NonNull ConnectionResult connectionResult, int i) {
+        if (zaE(connectionResult, i)) {
+            return;
+        }
+        Handler handler = this.zar;
+        handler.sendMessage(handler.obtainMessage(5, i, 0, connectionResult));
+    }
+
+    public final void zay() {
+        Handler handler = this.zar;
+        handler.sendMessage(handler.obtainMessage(3));
+    }
+
+    public final void zaz(@NonNull GoogleApi googleApi) {
+        Handler handler = this.zar;
+        handler.sendMessage(handler.obtainMessage(7, googleApi));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/GoogleServices.java

@@ -0,0 +1,156 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.gms.common.R;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.StringResourceValueReader;
+import com.google.android.gms.common.internal.zzah;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import csdk.gluads.Consts;
+
+@KeepForSdk
+@Deprecated
+/* loaded from: classes2.dex */
+public final class GoogleServices {
+    private static final Object zza = new Object();
+
+    @Nullable
+    private static GoogleServices zzb;
+
+    @Nullable
+    private final String zzc;
+    private final Status zzd;
+    private final boolean zze;
+    private final boolean zzf;
+
+    @KeepForSdk
+    @VisibleForTesting
+    public GoogleServices(Context context) {
+        Resources resources = context.getResources();
+        int identifier = resources.getIdentifier("google_app_measurement_enable", "integer", resources.getResourcePackageName(R.string.common_google_play_services_unknown_issue));
+        if (identifier != 0) {
+            int integer = resources.getInteger(identifier);
+            boolean z = integer == 0;
+            r2 = integer != 0;
+            this.zzf = z;
+        } else {
+            this.zzf = false;
+        }
+        this.zze = r2;
+        String zzb2 = zzah.zzb(context);
+        zzb2 = zzb2 == null ? new StringResourceValueReader(context).getString("google_app_id") : zzb2;
+        if (TextUtils.isEmpty(zzb2)) {
+            this.zzd = new Status(10, "Missing google app id value from from string resources with name google_app_id.");
+            this.zzc = null;
+        } else {
+            this.zzc = zzb2;
+            this.zzd = Status.RESULT_SUCCESS;
+        }
+    }
+
+    @KeepForSdk
+    @VisibleForTesting
+    public GoogleServices(String str, boolean z) {
+        this.zzc = str;
+        this.zzd = Status.RESULT_SUCCESS;
+        this.zze = z;
+        this.zzf = !z;
+    }
+
+    @KeepForSdk
+    private static GoogleServices checkInitialized(String str) {
+        GoogleServices googleServices;
+        synchronized (zza) {
+            try {
+                googleServices = zzb;
+                if (googleServices == null) {
+                    throw new IllegalStateException("Initialize must be called before " + str + Consts.STRING_PERIOD);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return googleServices;
+    }
+
+    @KeepForSdk
+    @VisibleForTesting
+    public static void clearInstanceForTest() {
+        synchronized (zza) {
+            zzb = null;
+        }
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static String getGoogleAppId() {
+        return checkInitialized("getGoogleAppId").zzc;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static Status initialize(@NonNull Context context) {
+        Status status;
+        Preconditions.checkNotNull(context, "Context must not be null.");
+        synchronized (zza) {
+            try {
+                if (zzb == null) {
+                    zzb = new GoogleServices(context);
+                }
+                status = zzb.zzd;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return status;
+    }
+
+    @KeepForSdk
+    public static boolean isMeasurementEnabled() {
+        GoogleServices checkInitialized = checkInitialized("isMeasurementEnabled");
+        return checkInitialized.zzd.isSuccess() && checkInitialized.zze;
+    }
+
+    @KeepForSdk
+    public static boolean isMeasurementExplicitlyDisabled() {
+        return checkInitialized("isMeasurementExplicitlyDisabled").zzf;
+    }
+
+    @KeepForSdk
+    @VisibleForTesting
+    public Status checkGoogleAppId(String str) {
+        String str2 = this.zzc;
+        if (str2 == null || str2.equals(str)) {
+            return Status.RESULT_SUCCESS;
+        }
+        return new Status(10, "Initialize was called with two different Google App IDs.  Only the first app ID will be used: '" + this.zzc + "'.");
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public static Status initialize(@NonNull Context context, @NonNull String str, boolean z) {
+        Preconditions.checkNotNull(context, "Context must not be null.");
+        Preconditions.checkNotEmpty(str, "App ID must be nonempty.");
+        synchronized (zza) {
+            try {
+                GoogleServices googleServices = zzb;
+                if (googleServices != null) {
+                    return googleServices.checkGoogleAppId(str);
+                }
+                GoogleServices googleServices2 = new GoogleServices(str, z);
+                zzb = googleServices2;
+                return googleServices2.zzd;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/IStatusCallback.java

@@ -0,0 +1,40 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.Status;
+
+/* loaded from: classes2.dex */
+public interface IStatusCallback extends IInterface {
+
+    public static abstract class Stub extends com.google.android.gms.internal.base.zab implements IStatusCallback {
+        public Stub() {
+            super("com.google.android.gms.common.api.internal.IStatusCallback");
+        }
+
+        @NonNull
+        public static IStatusCallback asInterface(@NonNull IBinder iBinder) {
+            if (iBinder == null) {
+                return null;
+            }
+            IInterface queryLocalInterface = iBinder.queryLocalInterface("com.google.android.gms.common.api.internal.IStatusCallback");
+            return queryLocalInterface instanceof IStatusCallback ? (IStatusCallback) queryLocalInterface : new zaby(iBinder);
+        }
+
+        @Override // com.google.android.gms.internal.base.zab
+        public final boolean zaa(int i, @NonNull Parcel parcel, @NonNull Parcel parcel2, int i2) throws RemoteException {
+            if (i != 1) {
+                return false;
+            }
+            Status status = (Status) com.google.android.gms.internal.base.zac.zaa(parcel, Status.CREATOR);
+            com.google.android.gms.internal.base.zac.zab(parcel);
+            onResult(status);
+            return true;
+        }
+    }
+
+    void onResult(@NonNull Status status) throws RemoteException;
+}

decompiled/sources/com/google/android/gms/common/api/internal/LifecycleActivity.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import android.content.ContextWrapper;
+import androidx.annotation.NonNull;
+import androidx.fragment.app.FragmentActivity;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class LifecycleActivity {
+    private final Object zza;
+
+    public LifecycleActivity(@NonNull Activity activity) {
+        Preconditions.checkNotNull(activity, "Activity must not be null");
+        this.zza = activity;
+    }
+
+    @NonNull
+    public final Activity zza() {
+        return (Activity) this.zza;
+    }
+
+    @NonNull
+    public final FragmentActivity zzb() {
+        return (FragmentActivity) this.zza;
+    }
+
+    public final boolean zzc() {
+        return this.zza instanceof Activity;
+    }
+
+    public final boolean zzd() {
+        return this.zza instanceof FragmentActivity;
+    }
+
+    @KeepForSdk
+    public LifecycleActivity(@NonNull ContextWrapper contextWrapper) {
+        throw new UnsupportedOperationException();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/LifecycleCallback.java

@@ -0,0 +1,105 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import android.content.ContextWrapper;
+import android.content.Intent;
+import android.os.Bundle;
+import androidx.annotation.Keep;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class LifecycleCallback {
+
+    @NonNull
+    @KeepForSdk
+    protected final LifecycleFragment mLifecycleFragment;
+
+    @KeepForSdk
+    public LifecycleCallback(@NonNull LifecycleFragment lifecycleFragment) {
+        this.mLifecycleFragment = lifecycleFragment;
+    }
+
+    @Keep
+    private static LifecycleFragment getChimeraLifecycleFragmentImpl(LifecycleActivity lifecycleActivity) {
+        throw new IllegalStateException("Method not available in SDK.");
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static LifecycleFragment getFragment(@NonNull Activity activity) {
+        return getFragment(new LifecycleActivity(activity));
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void dump(@NonNull String str, @NonNull FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @NonNull String[] strArr) {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public Activity getActivity() {
+        Activity lifecycleActivity = this.mLifecycleFragment.getLifecycleActivity();
+        Preconditions.checkNotNull(lifecycleActivity);
+        return lifecycleActivity;
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onActivityResult(int i, int i2, @NonNull Intent intent) {
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onCreate(@Nullable Bundle bundle) {
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onDestroy() {
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onResume() {
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onSaveInstanceState(@NonNull Bundle bundle) {
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onStart() {
+    }
+
+    @KeepForSdk
+    @MainThread
+    public void onStop() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static LifecycleFragment getFragment(@NonNull ContextWrapper contextWrapper) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static LifecycleFragment getFragment(@NonNull LifecycleActivity lifecycleActivity) {
+        if (lifecycleActivity.zzd()) {
+            return zzd.zzc(lifecycleActivity.zzb());
+        }
+        if (lifecycleActivity.zzc()) {
+            return zzb.zzc(lifecycleActivity.zza());
+        }
+        throw new IllegalArgumentException("Can't get fragment for unexpected activity.");
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/LifecycleFragment.java

@@ -0,0 +1,31 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import android.content.Intent;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface LifecycleFragment {
+    @KeepForSdk
+    void addCallback(@NonNull String str, @NonNull LifecycleCallback lifecycleCallback);
+
+    @Nullable
+    @KeepForSdk
+    <T extends LifecycleCallback> T getCallbackOrNull(@NonNull String str, @NonNull Class<T> cls);
+
+    @Nullable
+    @KeepForSdk
+    Activity getLifecycleActivity();
+
+    @KeepForSdk
+    boolean isCreated();
+
+    @KeepForSdk
+    boolean isStarted();
+
+    @KeepForSdk
+    void startActivityForResult(@NonNull Intent intent, int i);
+}

decompiled/sources/com/google/android/gms/common/api/internal/ListenerHolder.java

@@ -0,0 +1,122 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.concurrent.HandlerExecutor;
+import java.util.concurrent.Executor;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class ListenerHolder<L> {
+    private final Executor zaa;
+
+    @Nullable
+    private volatile Object zab;
+
+    @Nullable
+    private volatile ListenerKey zac;
+
+    @KeepForSdk
+    public static final class ListenerKey<L> {
+        private final Object zaa;
+        private final String zab;
+
+        @KeepForSdk
+        public ListenerKey(L l, String str) {
+            this.zaa = l;
+            this.zab = str;
+        }
+
+        @KeepForSdk
+        public boolean equals(@Nullable Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (!(obj instanceof ListenerKey)) {
+                return false;
+            }
+            ListenerKey listenerKey = (ListenerKey) obj;
+            return this.zaa == listenerKey.zaa && this.zab.equals(listenerKey.zab);
+        }
+
+        @KeepForSdk
+        public int hashCode() {
+            return (System.identityHashCode(this.zaa) * 31) + this.zab.hashCode();
+        }
+
+        @NonNull
+        @KeepForSdk
+        public String toIdString() {
+            return this.zab + "@" + System.identityHashCode(this.zaa);
+        }
+    }
+
+    @KeepForSdk
+    public interface Notifier<L> {
+        @KeepForSdk
+        void notifyListener(@NonNull L l);
+
+        @KeepForSdk
+        void onNotifyListenerFailed();
+    }
+
+    @KeepForSdk
+    public ListenerHolder(@NonNull Looper looper, @NonNull L l, @NonNull String str) {
+        this.zaa = new HandlerExecutor(looper);
+        this.zab = Preconditions.checkNotNull(l, "Listener must not be null");
+        this.zac = new ListenerKey(l, Preconditions.checkNotEmpty(str));
+    }
+
+    @KeepForSdk
+    public void clear() {
+        this.zab = null;
+        this.zac = null;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public ListenerKey<L> getListenerKey() {
+        return this.zac;
+    }
+
+    @KeepForSdk
+    public boolean hasListener() {
+        return this.zab != null;
+    }
+
+    @KeepForSdk
+    public void notifyListener(@NonNull final Notifier<? super L> notifier) {
+        Preconditions.checkNotNull(notifier, "Notifier must not be null");
+        this.zaa.execute(new Runnable() { // from class: com.google.android.gms.common.api.internal.zacb
+            @Override // java.lang.Runnable
+            public final void run() {
+                ListenerHolder.this.zaa(notifier);
+            }
+        });
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public final void zaa(Notifier notifier) {
+        Object obj = this.zab;
+        if (obj == null) {
+            notifier.onNotifyListenerFailed();
+            return;
+        }
+        try {
+            notifier.notifyListener(obj);
+        } catch (RuntimeException e) {
+            notifier.onNotifyListenerFailed();
+            throw e;
+        }
+    }
+
+    @KeepForSdk
+    public ListenerHolder(@NonNull Executor executor, @NonNull L l, @NonNull String str) {
+        this.zaa = (Executor) Preconditions.checkNotNull(executor, "Executor must not be null");
+        this.zab = Preconditions.checkNotNull(l, "Listener must not be null");
+        this.zac = new ListenerKey(l, Preconditions.checkNotEmpty(str));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/ListenerHolders.java

@@ -0,0 +1,61 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.Executor;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class ListenerHolders {
+    private final Set zaa = Collections.newSetFromMap(new WeakHashMap());
+
+    @NonNull
+    @KeepForSdk
+    public static <L> ListenerHolder<L> createListenerHolder(@NonNull L l, @NonNull Looper looper, @NonNull String str) {
+        Preconditions.checkNotNull(l, "Listener must not be null");
+        Preconditions.checkNotNull(looper, "Looper must not be null");
+        Preconditions.checkNotNull(str, "Listener type must not be null");
+        return new ListenerHolder<>(looper, l, str);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <L> ListenerHolder.ListenerKey<L> createListenerKey(@NonNull L l, @NonNull String str) {
+        Preconditions.checkNotNull(l, "Listener must not be null");
+        Preconditions.checkNotNull(str, "Listener type must not be null");
+        Preconditions.checkNotEmpty(str, "Listener type must not be empty");
+        return new ListenerHolder.ListenerKey<>(l, str);
+    }
+
+    @NonNull
+    public final ListenerHolder zaa(@NonNull Object obj, @NonNull Looper looper, @NonNull String str) {
+        Set set = this.zaa;
+        ListenerHolder createListenerHolder = createListenerHolder(obj, looper, "NO_TYPE");
+        set.add(createListenerHolder);
+        return createListenerHolder;
+    }
+
+    public final void zab() {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((ListenerHolder) it.next()).clear();
+        }
+        this.zaa.clear();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <L> ListenerHolder<L> createListenerHolder(@NonNull L l, @NonNull Executor executor, @NonNull String str) {
+        Preconditions.checkNotNull(l, "Listener must not be null");
+        Preconditions.checkNotNull(executor, "Executor must not be null");
+        Preconditions.checkNotNull(str, "Listener type must not be null");
+        return new ListenerHolder<>(executor, l, str);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/NonGmsServiceBrokerClient.java

@@ -0,0 +1,309 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Scope;
+import com.google.android.gms.common.internal.BaseGmsClient;
+import com.google.android.gms.common.internal.GmsClientSupervisor;
+import com.google.android.gms.common.internal.IAccountAccessor;
+import com.google.android.gms.common.internal.Preconditions;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.Set;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class NonGmsServiceBrokerClient implements Api.Client, ServiceConnection {
+    private static final String zaa = "NonGmsServiceBrokerClient";
+
+    @Nullable
+    private final String zab;
+
+    @Nullable
+    private final String zac;
+
+    @Nullable
+    private final ComponentName zad;
+    private final Context zae;
+    private final ConnectionCallbacks zaf;
+    private final Handler zag;
+    private final OnConnectionFailedListener zah;
+
+    @Nullable
+    private IBinder zai;
+    private boolean zaj;
+
+    @Nullable
+    private String zak;
+
+    @Nullable
+    private String zal;
+
+    @KeepForSdk
+    public NonGmsServiceBrokerClient(@NonNull Context context, @NonNull Looper looper, @NonNull ComponentName componentName, @NonNull ConnectionCallbacks connectionCallbacks, @NonNull OnConnectionFailedListener onConnectionFailedListener) {
+        this(context, looper, null, null, componentName, connectionCallbacks, onConnectionFailedListener);
+    }
+
+    @WorkerThread
+    private final void zad() {
+        if (Thread.currentThread() != this.zag.getLooper().getThread()) {
+            throw new IllegalStateException("This method should only run on the NonGmsServiceBrokerClient's handler thread.");
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @WorkerThread
+    public final void connect(@NonNull BaseGmsClient.ConnectionProgressReportCallbacks connectionProgressReportCallbacks) {
+        zad();
+        if (isConnected()) {
+            try {
+                disconnect("connect() called when already connected");
+            } catch (Exception unused) {
+            }
+        }
+        try {
+            Intent intent = new Intent();
+            ComponentName componentName = this.zad;
+            if (componentName != null) {
+                intent.setComponent(componentName);
+            } else {
+                intent.setPackage(this.zab).setAction(this.zac);
+            }
+            boolean bindService = this.zae.bindService(intent, this, GmsClientSupervisor.getDefaultBindFlags());
+            this.zaj = bindService;
+            if (bindService) {
+                return;
+            }
+            this.zai = null;
+            this.zah.onConnectionFailed(new ConnectionResult(16));
+        } catch (SecurityException e) {
+            this.zaj = false;
+            this.zai = null;
+            throw e;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @WorkerThread
+    public final void disconnect() {
+        zad();
+        try {
+            this.zae.unbindService(this);
+        } catch (IllegalArgumentException unused) {
+        }
+        this.zaj = false;
+        this.zai = null;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final void dump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr) {
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @NonNull
+    public final Feature[] getAvailableFeatures() {
+        return new Feature[0];
+    }
+
+    @Nullable
+    @KeepForSdk
+    @WorkerThread
+    public IBinder getBinder() {
+        zad();
+        return this.zai;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @NonNull
+    public final String getEndpointPackageName() {
+        String str = this.zab;
+        if (str != null) {
+            return str;
+        }
+        Preconditions.checkNotNull(this.zad);
+        return this.zad.getPackageName();
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @Nullable
+    public final String getLastDisconnectMessage() {
+        return this.zak;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final int getMinApkVersion() {
+        return 0;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final void getRemoteService(@Nullable IAccountAccessor iAccountAccessor, @Nullable Set<Scope> set) {
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @NonNull
+    public final Feature[] getRequiredFeatures() {
+        return new Feature[0];
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @NonNull
+    public final Set<Scope> getScopesForConnectionlessNonSignIn() {
+        return Collections.emptySet();
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @Nullable
+    public final IBinder getServiceBrokerBinder() {
+        return null;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @NonNull
+    public final Intent getSignInIntent() {
+        return new Intent();
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @WorkerThread
+    public final boolean isConnected() {
+        zad();
+        return this.zai != null;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @WorkerThread
+    public final boolean isConnecting() {
+        zad();
+        return this.zaj;
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceConnected(@NonNull ComponentName componentName, @NonNull final IBinder iBinder) {
+        this.zag.post(new Runnable() { // from class: com.google.android.gms.common.api.internal.zacg
+            @Override // java.lang.Runnable
+            public final void run() {
+                NonGmsServiceBrokerClient.this.zaa(iBinder);
+            }
+        });
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceDisconnected(@NonNull ComponentName componentName) {
+        this.zag.post(new Runnable() { // from class: com.google.android.gms.common.api.internal.zacf
+            @Override // java.lang.Runnable
+            public final void run() {
+                NonGmsServiceBrokerClient.this.zab();
+            }
+        });
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final void onUserSignOut(@NonNull BaseGmsClient.SignOutCallbacks signOutCallbacks) {
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final boolean providesSignIn() {
+        return false;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final boolean requiresAccount() {
+        return false;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final boolean requiresGooglePlayServices() {
+        return false;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final boolean requiresSignIn() {
+        return false;
+    }
+
+    public final /* synthetic */ void zaa(IBinder iBinder) {
+        this.zaj = false;
+        this.zai = iBinder;
+        this.zaf.onConnected(new Bundle());
+    }
+
+    public final void zac(@Nullable String str) {
+        this.zal = str;
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:11:0x001e, code lost:
+    
+        if (r6 != null) goto L8;
+     */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private NonGmsServiceBrokerClient(android.content.Context r2, android.os.Looper r3, @androidx.annotation.Nullable java.lang.String r4, @androidx.annotation.Nullable java.lang.String r5, @androidx.annotation.Nullable android.content.ComponentName r6, com.google.android.gms.common.api.internal.ConnectionCallbacks r7, com.google.android.gms.common.api.internal.OnConnectionFailedListener r8) {
+        /*
+            r1 = this;
+            r1.<init>()
+            r0 = 0
+            r1.zaj = r0
+            r0 = 0
+            r1.zak = r0
+            r1.zae = r2
+            com.google.android.gms.internal.base.zau r2 = new com.google.android.gms.internal.base.zau
+            r2.<init>(r3)
+            r1.zag = r2
+            r1.zaf = r7
+            r1.zah = r8
+            if (r4 == 0) goto L1e
+            if (r5 == 0) goto L1e
+            if (r6 != 0) goto L27
+            r6 = r0
+            goto L20
+        L1e:
+            if (r6 == 0) goto L27
+        L20:
+            r1.zab = r4
+            r1.zac = r5
+            r1.zad = r6
+            return
+        L27:
+            java.lang.AssertionError r2 = new java.lang.AssertionError
+            java.lang.String r3 = "Must specify either package or component, but not both"
+            r2.<init>(r3)
+            throw r2
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.api.internal.NonGmsServiceBrokerClient.<init>(android.content.Context, android.os.Looper, java.lang.String, java.lang.String, android.content.ComponentName, com.google.android.gms.common.api.internal.ConnectionCallbacks, com.google.android.gms.common.api.internal.OnConnectionFailedListener):void");
+    }
+
+    public final /* synthetic */ void zab() {
+        this.zaj = false;
+        this.zai = null;
+        this.zaf.onConnectionSuspended(1);
+    }
+
+    @KeepForSdk
+    public NonGmsServiceBrokerClient(@NonNull Context context, @NonNull Looper looper, @NonNull String str, @NonNull String str2, @NonNull ConnectionCallbacks connectionCallbacks, @NonNull OnConnectionFailedListener onConnectionFailedListener) {
+        this(context, looper, str, str2, null, connectionCallbacks, onConnectionFailedListener);
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    @WorkerThread
+    public final void disconnect(@NonNull String str) {
+        zad();
+        this.zak = str;
+        disconnect();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/OnConnectionFailedListener.java

@@ -0,0 +1,14 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface OnConnectionFailedListener {
+    @ShowFirstParty
+    @KeepForSdk
+    void onConnectionFailed(@NonNull ConnectionResult connectionResult);
+}

decompiled/sources/com/google/android/gms/common/api/internal/OptionalPendingResultImpl.java

@@ -0,0 +1,78 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.OptionalPendingResult;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultCallback;
+import com.google.android.gms.common.api.ResultTransform;
+import com.google.android.gms.common.api.TransformedResult;
+import java.util.concurrent.TimeUnit;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class OptionalPendingResultImpl<R extends Result> extends OptionalPendingResult<R> {
+    private final BasePendingResult zaa;
+
+    public OptionalPendingResultImpl(@NonNull PendingResult pendingResult) {
+        this.zaa = (BasePendingResult) pendingResult;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void addStatusListener(@NonNull PendingResult.StatusListener statusListener) {
+        this.zaa.addStatusListener(statusListener);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final R await() {
+        return (R) this.zaa.await();
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void cancel() {
+        this.zaa.cancel();
+    }
+
+    @Override // com.google.android.gms.common.api.OptionalPendingResult
+    @NonNull
+    public final R get() {
+        if (this.zaa.isReady()) {
+            return (R) this.zaa.await(0L, TimeUnit.MILLISECONDS);
+        }
+        throw new IllegalStateException("Result is not available. Check that isDone() returns true before calling get().");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final boolean isCanceled() {
+        return this.zaa.isCanceled();
+    }
+
+    @Override // com.google.android.gms.common.api.OptionalPendingResult
+    public final boolean isDone() {
+        return this.zaa.isReady();
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(@NonNull ResultCallback<? super R> resultCallback) {
+        this.zaa.setResultCallback(resultCallback);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final <S extends Result> TransformedResult<S> then(@NonNull ResultTransform<? super R, ? extends S> resultTransform) {
+        return this.zaa.then(resultTransform);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final R await(long j, @NonNull TimeUnit timeUnit) {
+        return (R) this.zaa.await(j, timeUnit);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(@NonNull ResultCallback<? super R> resultCallback, long j, @NonNull TimeUnit timeUnit) {
+        this.zaa.setResultCallback(resultCallback, j, timeUnit);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/PendingResultFacade.java

@@ -0,0 +1,59 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultCallback;
+import com.google.android.gms.common.api.ResultTransform;
+import com.google.android.gms.common.api.TransformedResult;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.concurrent.TimeUnit;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class PendingResultFacade<A extends Result, B extends Result> extends PendingResult<B> {
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void addStatusListener(@NonNull PendingResult.StatusListener statusListener) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final B await() {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final B await(long j, @NonNull TimeUnit timeUnit) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void cancel() {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final boolean isCanceled() {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(@NonNull ResultCallback<? super B> resultCallback) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(@NonNull ResultCallback<? super B> resultCallback, long j, @NonNull TimeUnit timeUnit) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public final <S extends Result> TransformedResult<S> then(@NonNull ResultTransform<? super B, ? extends S> resultTransform) {
+        throw null;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/RegisterListenerMethod.java

@@ -0,0 +1,68 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Api.AnyClient;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class RegisterListenerMethod<A extends Api.AnyClient, L> {
+    private final ListenerHolder zaa;
+
+    @Nullable
+    private final Feature[] zab;
+    private final boolean zac;
+    private final int zad;
+
+    @KeepForSdk
+    public RegisterListenerMethod(@NonNull ListenerHolder<L> listenerHolder) {
+        this(listenerHolder, null, false, 0);
+    }
+
+    @KeepForSdk
+    public RegisterListenerMethod(@NonNull ListenerHolder<L> listenerHolder, @Nullable Feature[] featureArr, boolean z, int i) {
+        this.zaa = listenerHolder;
+        this.zab = featureArr;
+        this.zac = z;
+        this.zad = i;
+    }
+
+    @KeepForSdk
+    public void clearListener() {
+        this.zaa.clear();
+    }
+
+    @Nullable
+    @KeepForSdk
+    public ListenerHolder.ListenerKey<L> getListenerKey() {
+        return this.zaa.getListenerKey();
+    }
+
+    @Nullable
+    @KeepForSdk
+    public Feature[] getRequiredFeatures() {
+        return this.zab;
+    }
+
+    @KeepForSdk
+    public abstract void registerListener(@NonNull A a, @NonNull TaskCompletionSource<Void> taskCompletionSource) throws RemoteException;
+
+    public final int zaa() {
+        return this.zad;
+    }
+
+    public final boolean zab() {
+        return this.zac;
+    }
+
+    @KeepForSdk
+    public RegisterListenerMethod(@NonNull ListenerHolder<L> listenerHolder, @NonNull Feature[] featureArr, boolean z) {
+        this(listenerHolder, featureArr, z, 0);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/RegistrationMethods.java

@@ -0,0 +1,112 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Api.AnyClient;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class RegistrationMethods<A extends Api.AnyClient, L> {
+
+    @NonNull
+    @KeepForSdk
+    public final RegisterListenerMethod<A, L> register;
+
+    @NonNull
+    public final UnregisterListenerMethod zaa;
+
+    @NonNull
+    public final Runnable zab;
+
+    @KeepForSdk
+    public static class Builder<A extends Api.AnyClient, L> {
+        private RemoteCall zaa;
+        private RemoteCall zab;
+        private ListenerHolder zad;
+        private Feature[] zae;
+        private int zag;
+        private Runnable zac = zacj.zaa;
+        private boolean zaf = true;
+
+        private Builder() {
+        }
+
+        public /* synthetic */ Builder(zacm zacmVar) {
+        }
+
+        @NonNull
+        @KeepForSdk
+        public RegistrationMethods<A, L> build() {
+            Preconditions.checkArgument(this.zaa != null, "Must set register function");
+            Preconditions.checkArgument(this.zab != null, "Must set unregister function");
+            Preconditions.checkArgument(this.zad != null, "Must set holder");
+            return new RegistrationMethods<>(new zack(this, this.zad, this.zae, this.zaf, this.zag), new zacl(this, (ListenerHolder.ListenerKey) Preconditions.checkNotNull(this.zad.getListenerKey(), "Key must not be null")), this.zac, null);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> onConnectionSuspended(@NonNull Runnable runnable) {
+            this.zac = runnable;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> register(@NonNull RemoteCall<A, TaskCompletionSource<Void>> remoteCall) {
+            this.zaa = remoteCall;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> setAutoResolveMissingFeatures(boolean z) {
+            this.zaf = z;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> setFeatures(@NonNull Feature... featureArr) {
+            this.zae = featureArr;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> setMethodKey(int i) {
+            this.zag = i;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> unregister(@NonNull RemoteCall<A, TaskCompletionSource<Boolean>> remoteCall) {
+            this.zab = remoteCall;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, L> withHolder(@NonNull ListenerHolder<L> listenerHolder) {
+            this.zad = listenerHolder;
+            return this;
+        }
+    }
+
+    public /* synthetic */ RegistrationMethods(RegisterListenerMethod registerListenerMethod, UnregisterListenerMethod unregisterListenerMethod, Runnable runnable, zacn zacnVar) {
+        this.register = registerListenerMethod;
+        this.zaa = unregisterListenerMethod;
+        this.zab = runnable;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <A extends Api.AnyClient, L> Builder<A, L> builder() {
+        return new Builder<>(null);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/RemoteCall.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface RemoteCall<T, U> {
+    @KeepForSdk
+    void accept(@NonNull T t, @NonNull U u) throws RemoteException;
+}

decompiled/sources/com/google/android/gms/common/api/internal/SignInConnectionListener.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface SignInConnectionListener {
+    @KeepForSdk
+    void onComplete();
+}

decompiled/sources/com/google/android/gms/common/api/internal/StatusCallback.java

@@ -0,0 +1,26 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.api.internal.IStatusCallback;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class StatusCallback extends IStatusCallback.Stub {
+
+    @KeepForSdk
+    private final BaseImplementation.ResultHolder<Status> resultHolder;
+
+    @KeepForSdk
+    public StatusCallback(@NonNull BaseImplementation.ResultHolder<Status> resultHolder) {
+        this.resultHolder = resultHolder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.IStatusCallback
+    @KeepForSdk
+    public void onResult(@NonNull Status status) {
+        this.resultHolder.setResult(status);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/StatusExceptionMapper.java

@@ -0,0 +1,13 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Status;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface StatusExceptionMapper {
+    @NonNull
+    @KeepForSdk
+    Exception getException(@NonNull Status status);
+}

decompiled/sources/com/google/android/gms/common/api/internal/StatusPendingResult.java

@@ -0,0 +1,27 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.Status;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class StatusPendingResult extends BasePendingResult<Status> {
+    @Deprecated
+    public StatusPendingResult(@NonNull Looper looper) {
+        super(looper);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.BasePendingResult
+    @NonNull
+    public final /* bridge */ /* synthetic */ Status createFailedResult(@NonNull Status status) {
+        return status;
+    }
+
+    @KeepForSdk
+    public StatusPendingResult(@NonNull GoogleApiClient googleApiClient) {
+        super(googleApiClient);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/TaskApiCall.java

@@ -0,0 +1,126 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Api.AnyClient;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.BiConsumer;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class TaskApiCall<A extends Api.AnyClient, ResultT> {
+
+    @Nullable
+    private final Feature[] zaa;
+    private final boolean zab;
+    private final int zac;
+
+    @KeepForSdk
+    public static class Builder<A extends Api.AnyClient, ResultT> {
+        private RemoteCall zaa;
+        private Feature[] zac;
+        private boolean zab = true;
+        private int zad = 0;
+
+        private Builder() {
+        }
+
+        public /* synthetic */ Builder(zacw zacwVar) {
+        }
+
+        @NonNull
+        @KeepForSdk
+        public TaskApiCall<A, ResultT> build() {
+            Preconditions.checkArgument(this.zaa != null, "execute parameter required");
+            return new zacv(this, this.zac, this.zab, this.zad);
+        }
+
+        @NonNull
+        @KeepForSdk
+        @Deprecated
+        public Builder<A, ResultT> execute(@NonNull final BiConsumer<A, TaskCompletionSource<ResultT>> biConsumer) {
+            this.zaa = new RemoteCall() { // from class: com.google.android.gms.common.api.internal.zacu
+                @Override // com.google.android.gms.common.api.internal.RemoteCall
+                public final void accept(Object obj, Object obj2) {
+                    BiConsumer.this.accept((Api.AnyClient) obj, (TaskCompletionSource) obj2);
+                }
+            };
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, ResultT> run(@NonNull RemoteCall<A, TaskCompletionSource<ResultT>> remoteCall) {
+            this.zaa = remoteCall;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, ResultT> setAutoResolveMissingFeatures(boolean z) {
+            this.zab = z;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, ResultT> setFeatures(@NonNull Feature... featureArr) {
+            this.zac = featureArr;
+            return this;
+        }
+
+        @NonNull
+        @KeepForSdk
+        public Builder<A, ResultT> setMethodKey(int i) {
+            this.zad = i;
+            return this;
+        }
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public TaskApiCall() {
+        this.zaa = null;
+        this.zab = false;
+        this.zac = 0;
+    }
+
+    @KeepForSdk
+    public TaskApiCall(@Nullable Feature[] featureArr, boolean z, int i) {
+        this.zaa = featureArr;
+        boolean z2 = false;
+        if (featureArr != null && z) {
+            z2 = true;
+        }
+        this.zab = z2;
+        this.zac = i;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <A extends Api.AnyClient, ResultT> Builder<A, ResultT> builder() {
+        return new Builder<>(null);
+    }
+
+    @KeepForSdk
+    public abstract void doExecute(@NonNull A a, @NonNull TaskCompletionSource<ResultT> taskCompletionSource) throws RemoteException;
+
+    @KeepForSdk
+    public boolean shouldAutoResolveMissingFeatures() {
+        return this.zab;
+    }
+
+    public final int zaa() {
+        return this.zac;
+    }
+
+    @Nullable
+    public final Feature[] zab() {
+        return this.zaa;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/TaskUtil.java

@@ -0,0 +1,41 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.internal.ApiExceptionUtil;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class TaskUtil {
+    @KeepForSdk
+    public static void setResultOrApiException(@NonNull Status status, @NonNull TaskCompletionSource<Void> taskCompletionSource) {
+        setResultOrApiException(status, null, taskCompletionSource);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static Task<Void> toVoidTaskThatFailsOnFalse(@NonNull Task<Boolean> task) {
+        return task.continueWith(new zacx());
+    }
+
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public static <ResultT> boolean trySetResultOrApiException(@NonNull Status status, @Nullable ResultT resultt, @NonNull TaskCompletionSource<ResultT> taskCompletionSource) {
+        return status.isSuccess() ? taskCompletionSource.trySetResult(resultt) : taskCompletionSource.trySetException(ApiExceptionUtil.fromStatus(status));
+    }
+
+    @KeepForSdk
+    public static <ResultT> void setResultOrApiException(@NonNull Status status, @Nullable ResultT resultt, @NonNull TaskCompletionSource<ResultT> taskCompletionSource) {
+        if (status.isSuccess()) {
+            taskCompletionSource.setResult(resultt);
+        } else {
+            taskCompletionSource.setException(ApiExceptionUtil.fromStatus(status));
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/UnregisterListenerMethod.java

@@ -0,0 +1,29 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Api.AnyClient;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public abstract class UnregisterListenerMethod<A extends Api.AnyClient, L> {
+    private final ListenerHolder.ListenerKey zaa;
+
+    @KeepForSdk
+    public UnregisterListenerMethod(@NonNull ListenerHolder.ListenerKey<L> listenerKey) {
+        this.zaa = listenerKey;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public ListenerHolder.ListenerKey<L> getListenerKey() {
+        return this.zaa;
+    }
+
+    @KeepForSdk
+    public abstract void unregisterListener(@NonNull A a, @NonNull TaskCompletionSource<Boolean> taskCompletionSource) throws RemoteException;
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaa.java

@@ -0,0 +1,55 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import androidx.annotation.MainThread;
+import androidx.annotation.VisibleForTesting;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+@VisibleForTesting(otherwise = 2)
+/* loaded from: classes2.dex */
+final class zaa extends LifecycleCallback {
+    private List zaa;
+
+    private zaa(LifecycleFragment lifecycleFragment) {
+        super(lifecycleFragment);
+        this.zaa = new ArrayList();
+        this.mLifecycleFragment.addCallback("LifecycleObserverOnStop", this);
+    }
+
+    public static /* bridge */ /* synthetic */ zaa zaa(Activity activity) {
+        zaa zaaVar;
+        synchronized (activity) {
+            try {
+                LifecycleFragment fragment = LifecycleCallback.getFragment(activity);
+                zaaVar = (zaa) fragment.getCallbackOrNull("LifecycleObserverOnStop", zaa.class);
+                if (zaaVar == null) {
+                    zaaVar = new zaa(fragment);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zaaVar;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final synchronized void zac(Runnable runnable) {
+        this.zaa.add(runnable);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.LifecycleCallback
+    @MainThread
+    public final void onStop() {
+        List list;
+        synchronized (this) {
+            list = this.zaa;
+            this.zaa = new ArrayList();
+        }
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            ((Runnable) it.next()).run();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaaa.java

@@ -0,0 +1,402 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.ArrayMap;
+import com.facebook.internal.security.CertificateUtil;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+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.Lock;
+
+/* loaded from: classes2.dex */
+final class zaaa implements zaca {
+    private final Context zaa;
+    private final zabe zab;
+    private final Looper zac;
+    private final zabi zad;
+    private final zabi zae;
+    private final Map zaf;
+
+    @Nullable
+    private final Api.Client zah;
+
+    @Nullable
+    private Bundle zai;
+    private final Lock zam;
+    private final Set zag = Collections.newSetFromMap(new WeakHashMap());
+
+    @Nullable
+    private ConnectionResult zaj = null;
+
+    @Nullable
+    private ConnectionResult zak = null;
+    private boolean zal = false;
+    private int zan = 0;
+
+    private zaaa(Context context, zabe zabeVar, Lock lock, Looper looper, GoogleApiAvailabilityLight googleApiAvailabilityLight, Map map, Map map2, ClientSettings clientSettings, Api.AbstractClientBuilder abstractClientBuilder, @Nullable Api.Client client, ArrayList arrayList, ArrayList arrayList2, Map map3, Map map4) {
+        this.zaa = context;
+        this.zab = zabeVar;
+        this.zam = lock;
+        this.zac = looper;
+        this.zah = client;
+        this.zad = new zabi(context, zabeVar, lock, looper, googleApiAvailabilityLight, map2, null, map4, null, arrayList2, new zax(this, null));
+        this.zae = new zabi(context, zabeVar, lock, looper, googleApiAvailabilityLight, map, clientSettings, map3, abstractClientBuilder, arrayList, new zaz(this, null));
+        ArrayMap arrayMap = new ArrayMap();
+        Iterator it = map2.keySet().iterator();
+        while (it.hasNext()) {
+            arrayMap.put((Api.AnyClientKey) it.next(), this.zad);
+        }
+        Iterator it2 = map.keySet().iterator();
+        while (it2.hasNext()) {
+            arrayMap.put((Api.AnyClientKey) it2.next(), this.zae);
+        }
+        this.zaf = Collections.unmodifiableMap(arrayMap);
+    }
+
+    private final void zaB() {
+        Iterator it = this.zag.iterator();
+        while (it.hasNext()) {
+            ((SignInConnectionListener) it.next()).onComplete();
+        }
+        this.zag.clear();
+    }
+
+    private final boolean zaC() {
+        ConnectionResult connectionResult = this.zak;
+        return connectionResult != null && connectionResult.getErrorCode() == 4;
+    }
+
+    private final boolean zaD(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        zabi zabiVar = (zabi) this.zaf.get(apiMethodImpl.getClientKey());
+        Preconditions.checkNotNull(zabiVar, "GoogleApiClient is not configured to use the API required for this call.");
+        return zabiVar.equals(this.zae);
+    }
+
+    private static boolean zaE(@Nullable ConnectionResult connectionResult) {
+        return connectionResult != null && connectionResult.isSuccess();
+    }
+
+    public static zaaa zag(Context context, zabe zabeVar, Lock lock, Looper looper, GoogleApiAvailabilityLight googleApiAvailabilityLight, Map map, ClientSettings clientSettings, Map map2, Api.AbstractClientBuilder abstractClientBuilder, ArrayList arrayList) {
+        ArrayMap arrayMap = new ArrayMap();
+        ArrayMap arrayMap2 = new ArrayMap();
+        Api.Client client = null;
+        for (Map.Entry entry : map.entrySet()) {
+            Api.Client client2 = (Api.Client) entry.getValue();
+            if (true == client2.providesSignIn()) {
+                client = client2;
+            }
+            if (client2.requiresSignIn()) {
+                arrayMap.put((Api.AnyClientKey) entry.getKey(), client2);
+            } else {
+                arrayMap2.put((Api.AnyClientKey) entry.getKey(), client2);
+            }
+        }
+        Preconditions.checkState(!arrayMap.isEmpty(), "CompositeGoogleApiClient should not be used without any APIs that require sign-in.");
+        ArrayMap arrayMap3 = new ArrayMap();
+        ArrayMap arrayMap4 = new ArrayMap();
+        for (Api api : map2.keySet()) {
+            Api.AnyClientKey zab = api.zab();
+            if (arrayMap.containsKey(zab)) {
+                arrayMap3.put(api, (Boolean) map2.get(api));
+            } else {
+                if (!arrayMap2.containsKey(zab)) {
+                    throw new IllegalStateException("Each API in the isOptionalMap must have a corresponding client in the clients map.");
+                }
+                arrayMap4.put(api, (Boolean) map2.get(api));
+            }
+        }
+        ArrayList arrayList2 = new ArrayList();
+        ArrayList arrayList3 = new ArrayList();
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            zat zatVar = (zat) arrayList.get(i);
+            if (arrayMap3.containsKey(zatVar.zaa)) {
+                arrayList2.add(zatVar);
+            } else {
+                if (!arrayMap4.containsKey(zatVar.zaa)) {
+                    throw new IllegalStateException("Each ClientCallbacks must have a corresponding API in the isOptionalMap");
+                }
+                arrayList3.add(zatVar);
+            }
+        }
+        return new zaaa(context, zabeVar, lock, looper, googleApiAvailabilityLight, arrayMap, arrayMap2, clientSettings, abstractClientBuilder, client, arrayList2, arrayList3, arrayMap3, arrayMap4);
+    }
+
+    public static /* bridge */ /* synthetic */ void zan(zaaa zaaaVar, int i, boolean z) {
+        zaaaVar.zab.zac(i, z);
+        zaaaVar.zak = null;
+        zaaaVar.zaj = null;
+    }
+
+    public static /* bridge */ /* synthetic */ void zao(zaaa zaaaVar, Bundle bundle) {
+        Bundle bundle2 = zaaaVar.zai;
+        if (bundle2 == null) {
+            zaaaVar.zai = bundle;
+        } else if (bundle != null) {
+            bundle2.putAll(bundle);
+        }
+    }
+
+    public static /* bridge */ /* synthetic */ void zap(zaaa zaaaVar) {
+        ConnectionResult connectionResult;
+        if (!zaE(zaaaVar.zaj)) {
+            if (zaaaVar.zaj != null && zaE(zaaaVar.zak)) {
+                zaaaVar.zae.zar();
+                zaaaVar.zaA((ConnectionResult) Preconditions.checkNotNull(zaaaVar.zaj));
+                return;
+            }
+            ConnectionResult connectionResult2 = zaaaVar.zaj;
+            if (connectionResult2 == null || (connectionResult = zaaaVar.zak) == null) {
+                return;
+            }
+            if (zaaaVar.zae.zaf < zaaaVar.zad.zaf) {
+                connectionResult2 = connectionResult;
+            }
+            zaaaVar.zaA(connectionResult2);
+            return;
+        }
+        if (!zaE(zaaaVar.zak) && !zaaaVar.zaC()) {
+            ConnectionResult connectionResult3 = zaaaVar.zak;
+            if (connectionResult3 != null) {
+                if (zaaaVar.zan == 1) {
+                    zaaaVar.zaB();
+                    return;
+                } else {
+                    zaaaVar.zaA(connectionResult3);
+                    zaaaVar.zad.zar();
+                    return;
+                }
+            }
+            return;
+        }
+        int i = zaaaVar.zan;
+        if (i != 1) {
+            if (i != 2) {
+                Log.wtf("CompositeGAC", "Attempted to call success callbacks in CONNECTION_MODE_NONE. Callbacks should be disabled via GmsClientSupervisor", new AssertionError());
+                zaaaVar.zan = 0;
+            }
+            ((zabe) Preconditions.checkNotNull(zaaaVar.zab)).zab(zaaaVar.zai);
+        }
+        zaaaVar.zaB();
+        zaaaVar.zan = 0;
+    }
+
+    @Nullable
+    private final PendingIntent zaz() {
+        Api.Client client = this.zah;
+        if (client == null) {
+            return null;
+        }
+        return PendingIntent.getActivity(this.zaa, System.identityHashCode(this.zab), client.getSignInIntent(), com.google.android.gms.internal.base.zap.zaa | 134217728);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final ConnectionResult zab() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final ConnectionResult zac(long j, @NonNull TimeUnit timeUnit) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    @Nullable
+    public final ConnectionResult zad(@NonNull Api api) {
+        return Objects.equal(this.zaf.get(api.zab()), this.zae) ? zaC() ? new ConnectionResult(4, zaz()) : this.zae.zad(api) : this.zad.zad(api);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final BaseImplementation.ApiMethodImpl zae(@NonNull BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        if (!zaD(apiMethodImpl)) {
+            this.zad.zae(apiMethodImpl);
+            return apiMethodImpl;
+        }
+        if (zaC()) {
+            apiMethodImpl.setFailedResult(new Status(4, (String) null, zaz()));
+            return apiMethodImpl;
+        }
+        this.zae.zae(apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final BaseImplementation.ApiMethodImpl zaf(@NonNull BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        if (!zaD(apiMethodImpl)) {
+            return this.zad.zaf(apiMethodImpl);
+        }
+        if (!zaC()) {
+            return this.zae.zaf(apiMethodImpl);
+        }
+        apiMethodImpl.setFailedResult(new Status(4, (String) null, zaz()));
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zaq() {
+        this.zan = 2;
+        this.zal = false;
+        this.zak = null;
+        this.zaj = null;
+        this.zad.zaq();
+        this.zae.zaq();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zar() {
+        this.zak = null;
+        this.zaj = null;
+        this.zan = 0;
+        this.zad.zar();
+        this.zae.zar();
+        zaB();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zas(String str, @Nullable FileDescriptor fileDescriptor, PrintWriter printWriter, @Nullable String[] strArr) {
+        printWriter.append((CharSequence) str).append("authClient").println(CertificateUtil.DELIMITER);
+        this.zae.zas(String.valueOf(str).concat("  "), fileDescriptor, printWriter, strArr);
+        printWriter.append((CharSequence) str).append("anonClient").println(CertificateUtil.DELIMITER);
+        this.zad.zas(String.valueOf(str).concat("  "), fileDescriptor, printWriter, strArr);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zat() {
+        this.zad.zat();
+        this.zae.zat();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zau() {
+        this.zam.lock();
+        try {
+            boolean zax = zax();
+            this.zae.zar();
+            this.zak = new ConnectionResult(4);
+            if (zax) {
+                new com.google.android.gms.internal.base.zau(this.zac).post(new zav(this));
+            } else {
+                zaB();
+            }
+            this.zam.unlock();
+        } catch (Throwable th) {
+            this.zam.unlock();
+            throw th;
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:10:0x001f, code lost:
+    
+        if (r3.zan == 1) goto L11;
+     */
+    @Override // com.google.android.gms.common.api.internal.zaca
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final boolean zaw() {
+        /*
+            r3 = this;
+            java.util.concurrent.locks.Lock r0 = r3.zam
+            r0.lock()
+            com.google.android.gms.common.api.internal.zabi r0 = r3.zad     // Catch: java.lang.Throwable -> L23
+            boolean r0 = r0.zaw()     // Catch: java.lang.Throwable -> L23
+            r1 = 0
+            if (r0 == 0) goto L25
+            com.google.android.gms.common.api.internal.zabi r0 = r3.zae     // Catch: java.lang.Throwable -> L23
+            boolean r0 = r0.zaw()     // Catch: java.lang.Throwable -> L23
+            r2 = 1
+            if (r0 != 0) goto L21
+            boolean r0 = r3.zaC()     // Catch: java.lang.Throwable -> L23
+            if (r0 != 0) goto L21
+            int r0 = r3.zan     // Catch: java.lang.Throwable -> L23
+            if (r0 != r2) goto L25
+        L21:
+            r1 = r2
+            goto L25
+        L23:
+            r0 = move-exception
+            goto L2b
+        L25:
+            java.util.concurrent.locks.Lock r0 = r3.zam
+            r0.unlock()
+            return r1
+        L2b:
+            java.util.concurrent.locks.Lock r1 = r3.zam
+            r1.unlock()
+            throw r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.api.internal.zaaa.zaw():boolean");
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final boolean zax() {
+        this.zam.lock();
+        try {
+            return this.zan == 2;
+        } finally {
+            this.zam.unlock();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final boolean zay(SignInConnectionListener signInConnectionListener) {
+        this.zam.lock();
+        try {
+            boolean z = false;
+            if (!zax()) {
+                if (zaw()) {
+                }
+                this.zam.unlock();
+                return z;
+            }
+            if (!this.zae.zaw()) {
+                this.zag.add(signInConnectionListener);
+                z = true;
+                if (this.zan == 0) {
+                    this.zan = 1;
+                }
+                this.zak = null;
+                this.zae.zaq();
+            }
+            this.zam.unlock();
+            return z;
+        } catch (Throwable th) {
+            this.zam.unlock();
+            throw th;
+        }
+    }
+
+    private final void zaA(ConnectionResult connectionResult) {
+        int i = this.zan;
+        if (i != 1) {
+            if (i != 2) {
+                Log.wtf("CompositeGAC", "Attempted to call failure callbacks in CONNECTION_MODE_NONE. Callbacks should be disabled via GmsClientSupervisor", new Exception());
+                this.zan = 0;
+            }
+            this.zab.zaa(connectionResult);
+        }
+        zaB();
+        this.zan = 0;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaab.java

@@ -0,0 +1,23 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Status;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+final class zaab implements PendingResult.StatusListener {
+    final /* synthetic */ BasePendingResult zaa;
+    final /* synthetic */ zaad zab;
+
+    public zaab(zaad zaadVar, BasePendingResult basePendingResult) {
+        this.zab = zaadVar;
+        this.zaa = basePendingResult;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult.StatusListener
+    public final void onComplete(Status status) {
+        Map map;
+        map = this.zab.zaa;
+        map.remove(this.zaa);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaac.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+final class zaac implements OnCompleteListener {
+    final /* synthetic */ TaskCompletionSource zaa;
+    final /* synthetic */ zaad zab;
+
+    public zaac(zaad zaadVar, TaskCompletionSource taskCompletionSource) {
+        this.zab = zaadVar;
+        this.zaa = taskCompletionSource;
+    }
+
+    @Override // com.google.android.gms.tasks.OnCompleteListener
+    public final void onComplete(@NonNull Task task) {
+        Map map;
+        map = this.zab.zab;
+        map.remove(this.zaa);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaad.java

@@ -0,0 +1,69 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/* loaded from: classes2.dex */
+public final class zaad {
+    private final Map zaa = Collections.synchronizedMap(new WeakHashMap());
+    private final Map zab = Collections.synchronizedMap(new WeakHashMap());
+
+    private final void zah(boolean z, Status status) {
+        HashMap hashMap;
+        HashMap hashMap2;
+        synchronized (this.zaa) {
+            hashMap = new HashMap(this.zaa);
+        }
+        synchronized (this.zab) {
+            hashMap2 = new HashMap(this.zab);
+        }
+        for (Map.Entry entry : hashMap.entrySet()) {
+            if (z || ((Boolean) entry.getValue()).booleanValue()) {
+                ((BasePendingResult) entry.getKey()).forceFailureUnlessReady(status);
+            }
+        }
+        for (Map.Entry entry2 : hashMap2.entrySet()) {
+            if (z || ((Boolean) entry2.getValue()).booleanValue()) {
+                ((TaskCompletionSource) entry2.getKey()).trySetException(new ApiException(status));
+            }
+        }
+    }
+
+    public final void zac(BasePendingResult basePendingResult, boolean z) {
+        this.zaa.put(basePendingResult, Boolean.valueOf(z));
+        basePendingResult.addStatusListener(new zaab(this, basePendingResult));
+    }
+
+    public final void zad(TaskCompletionSource taskCompletionSource, boolean z) {
+        this.zab.put(taskCompletionSource, Boolean.valueOf(z));
+        taskCompletionSource.getTask().addOnCompleteListener(new zaac(this, taskCompletionSource));
+    }
+
+    public final void zae(int i, @Nullable String str) {
+        StringBuilder sb = new StringBuilder("The connection to Google Play services was lost");
+        if (i == 1) {
+            sb.append(" due to service disconnection.");
+        } else if (i == 3) {
+            sb.append(" due to dead object exception.");
+        }
+        if (str != null) {
+            sb.append(" Last reason for disconnect: ");
+            sb.append(str);
+        }
+        zah(true, new Status(20, sb.toString()));
+    }
+
+    public final void zaf() {
+        zah(false, GoogleApiManager.zaa);
+    }
+
+    public final boolean zag() {
+        return (this.zaa.isEmpty() && this.zab.isEmpty()) ? false : true;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaae.java

@@ -0,0 +1,74 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import androidx.annotation.MainThread;
+import androidx.annotation.VisibleForTesting;
+import androidx.collection.ArraySet;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public final class zaae extends zap {
+    private final ArraySet zad;
+    private final GoogleApiManager zae;
+
+    @VisibleForTesting
+    public zaae(LifecycleFragment lifecycleFragment, GoogleApiManager googleApiManager, GoogleApiAvailability googleApiAvailability) {
+        super(lifecycleFragment, googleApiAvailability);
+        this.zad = new ArraySet();
+        this.zae = googleApiManager;
+        this.mLifecycleFragment.addCallback("ConnectionlessLifecycleHelper", this);
+    }
+
+    @MainThread
+    public static void zad(Activity activity, GoogleApiManager googleApiManager, ApiKey apiKey) {
+        LifecycleFragment fragment = LifecycleCallback.getFragment(activity);
+        zaae zaaeVar = (zaae) fragment.getCallbackOrNull("ConnectionlessLifecycleHelper", zaae.class);
+        if (zaaeVar == null) {
+            zaaeVar = new zaae(fragment, googleApiManager, GoogleApiAvailability.getInstance());
+        }
+        Preconditions.checkNotNull(apiKey, "ApiKey cannot be null");
+        zaaeVar.zad.add(apiKey);
+        googleApiManager.zaA(zaaeVar);
+    }
+
+    private final void zae() {
+        if (this.zad.isEmpty()) {
+            return;
+        }
+        this.zae.zaA(this);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.LifecycleCallback
+    public final void onResume() {
+        super.onResume();
+        zae();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap, com.google.android.gms.common.api.internal.LifecycleCallback
+    public final void onStart() {
+        super.onStart();
+        zae();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap, com.google.android.gms.common.api.internal.LifecycleCallback
+    public final void onStop() {
+        super.onStop();
+        this.zae.zaB(this);
+    }
+
+    public final ArraySet zaa() {
+        return this.zad;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap
+    public final void zab(ConnectionResult connectionResult, int i) {
+        this.zae.zax(connectionResult, i);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap
+    public final void zac() {
+        this.zae.zay();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaaf.java

@@ -0,0 +1,21 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* loaded from: classes2.dex */
+final class zaaf {
+    private final ApiKey zaa;
+    private final TaskCompletionSource zab = new TaskCompletionSource();
+
+    public zaaf(ApiKey apiKey) {
+        this.zaa = apiKey;
+    }
+
+    public final ApiKey zaa() {
+        return this.zaa;
+    }
+
+    public final TaskCompletionSource zab() {
+        return this.zab;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaag.java

@@ -0,0 +1,111 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import androidx.fragment.app.FragmentActivity;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Status;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public class zaag extends GoogleApiClient {
+    private final String zaa = "Method is not supported by connectionless client. APIs supporting connectionless client must not call this method.";
+
+    public zaag(String str) {
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final ConnectionResult blockingConnect() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final PendingResult<Status> clearDefaultAccountAndReconnect() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void connect() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void disconnect() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    @NonNull
+    public final ConnectionResult getConnectionResult(@NonNull Api<?> api) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean hasConnectedApi(@NonNull Api<?> api) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnected() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnecting() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnectionCallbacksRegistered(@NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnectionFailedListenerRegistered(@NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void reconnect() {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void registerConnectionCallbacks(@NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void registerConnectionFailedListener(@NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void stopAutoManage(@NonNull FragmentActivity fragmentActivity) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionCallbacks(@NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionFailedListener(@NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final ConnectionResult blockingConnect(long j, @NonNull TimeUnit timeUnit) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaah.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zaah extends zabg {
+    final /* synthetic */ zaaj zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaah(zaaj zaajVar, zabf zabfVar) {
+        super(zabfVar);
+        this.zaa = zaajVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabg
+    public final void zaa() {
+        this.zaa.zai(1);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaai.java

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zaai extends zabg {
+    final /* synthetic */ zaaj zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaai(zaaj zaajVar, zabf zabfVar) {
+        super(zabfVar);
+        this.zaa = zaajVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabg
+    public final void zaa() {
+        zabi zabiVar;
+        zabiVar = this.zaa.zaa;
+        zabiVar.zah.zab(null);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaaj.java

@@ -0,0 +1,98 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import android.os.DeadObjectException;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.Iterator;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class zaaj implements zabf {
+    private final zabi zaa;
+    private boolean zab = false;
+
+    public zaaj(zabi zabiVar) {
+        this.zaa = zabiVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final BaseImplementation.ApiMethodImpl zaa(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        zab(apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final BaseImplementation.ApiMethodImpl zab(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        try {
+            this.zaa.zag.zai.zaa(apiMethodImpl);
+            zabe zabeVar = this.zaa.zag;
+            Api.Client client = (Api.Client) zabeVar.zac.get(apiMethodImpl.getClientKey());
+            Preconditions.checkNotNull(client, "Appropriate Api was not requested.");
+            if (client.isConnected() || !this.zaa.zab.containsKey(apiMethodImpl.getClientKey())) {
+                apiMethodImpl.run(client);
+            } else {
+                apiMethodImpl.setFailedResult(new Status(17));
+            }
+        } catch (DeadObjectException unused) {
+            this.zaa.zal(new zaah(this, this));
+        }
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zad() {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zae() {
+        if (this.zab) {
+            this.zab = false;
+            this.zaa.zal(new zaai(this, this));
+        }
+    }
+
+    public final void zaf() {
+        if (this.zab) {
+            this.zab = false;
+            this.zaa.zag.zai.zab();
+            zaj();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zag(@Nullable Bundle bundle) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zah(ConnectionResult connectionResult, Api api, boolean z) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zai(int i) {
+        this.zaa.zak(null);
+        this.zaa.zah.zac(i, this.zab);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final boolean zaj() {
+        if (this.zab) {
+            return false;
+        }
+        Set set = this.zaa.zag.zah;
+        if (set == null || set.isEmpty()) {
+            this.zaa.zak(null);
+            return true;
+        }
+        this.zab = true;
+        Iterator it = set.iterator();
+        while (it.hasNext()) {
+            ((zada) it.next()).zah();
+        }
+        return false;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaak.java

@@ -0,0 +1,23 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+
+/* loaded from: classes2.dex */
+final class zaak implements Runnable {
+    final /* synthetic */ zaaw zaa;
+
+    public zaak(zaaw zaawVar) {
+        this.zaa = zaawVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        GoogleApiAvailabilityLight googleApiAvailabilityLight;
+        Context context;
+        zaaw zaawVar = this.zaa;
+        googleApiAvailabilityLight = zaawVar.zad;
+        context = zaawVar.zac;
+        googleApiAvailabilityLight.cancelAvailabilityErrorNotifications(context);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaal.java

@@ -0,0 +1,56 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.internal.BaseGmsClient;
+import com.google.android.gms.common.internal.Preconditions;
+import java.lang.ref.WeakReference;
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+final class zaal implements BaseGmsClient.ConnectionProgressReportCallbacks {
+    private final WeakReference zaa;
+    private final Api zab;
+    private final boolean zac;
+
+    public zaal(zaaw zaawVar, Api api, boolean z) {
+        this.zaa = new WeakReference(zaawVar);
+        this.zab = api;
+        this.zac = z;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient.ConnectionProgressReportCallbacks
+    public final void onReportServiceBinding(@NonNull ConnectionResult connectionResult) {
+        zabi zabiVar;
+        Lock lock;
+        Lock lock2;
+        boolean zaG;
+        boolean zaH;
+        zaaw zaawVar = (zaaw) this.zaa.get();
+        if (zaawVar == null) {
+            return;
+        }
+        Looper myLooper = Looper.myLooper();
+        zabiVar = zaawVar.zaa;
+        Preconditions.checkState(myLooper == zabiVar.zag.getLooper(), "onReportServiceBinding must be called on the GoogleApiClient handler thread");
+        lock = zaawVar.zab;
+        lock.lock();
+        try {
+            zaG = zaawVar.zaG(0);
+            if (zaG) {
+                if (!connectionResult.isSuccess()) {
+                    zaawVar.zaE(connectionResult, this.zab, this.zac);
+                }
+                zaH = zaawVar.zaH();
+                if (zaH) {
+                    zaawVar.zaF();
+                }
+            }
+        } finally {
+            lock2 = zaawVar.zab;
+            lock2.unlock();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaam.java

@@ -0,0 +1,21 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.ConnectionResult;
+
+/* loaded from: classes2.dex */
+final class zaam extends zabg {
+    final /* synthetic */ ConnectionResult zaa;
+    final /* synthetic */ zaao zab;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaam(zaao zaaoVar, zabf zabfVar, ConnectionResult connectionResult) {
+        super(zabfVar);
+        this.zab = zaaoVar;
+        this.zaa = connectionResult;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabg
+    public final void zaa() {
+        this.zab.zaa.zaD(this.zaa);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaan.java

@@ -0,0 +1,20 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.internal.BaseGmsClient;
+
+/* loaded from: classes2.dex */
+final class zaan extends zabg {
+    final /* synthetic */ BaseGmsClient.ConnectionProgressReportCallbacks zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaan(zaao zaaoVar, zabf zabfVar, BaseGmsClient.ConnectionProgressReportCallbacks connectionProgressReportCallbacks) {
+        super(zabfVar);
+        this.zaa = connectionProgressReportCallbacks;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabg
+    public final void zaa() {
+        this.zaa.onReportServiceBinding(new ConnectionResult(16, null));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaao.java

@@ -0,0 +1,104 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.internal.BaseGmsClient;
+import java.util.ArrayList;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+final class zaao extends zaav {
+    final /* synthetic */ zaaw zaa;
+    private final Map zac;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaao(zaaw zaawVar, Map map) {
+        super(zaawVar, null);
+        this.zaa = zaawVar;
+        this.zac = map;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaav
+    @WorkerThread
+    public final void zaa() {
+        GoogleApiAvailabilityLight googleApiAvailabilityLight;
+        Context context;
+        boolean z;
+        Context context2;
+        zabi zabiVar;
+        com.google.android.gms.signin.zae zaeVar;
+        com.google.android.gms.signin.zae zaeVar2;
+        zabi zabiVar2;
+        Context context3;
+        boolean z2;
+        googleApiAvailabilityLight = this.zaa.zad;
+        com.google.android.gms.common.internal.zal zalVar = new com.google.android.gms.common.internal.zal(googleApiAvailabilityLight);
+        ArrayList arrayList = new ArrayList();
+        ArrayList arrayList2 = new ArrayList();
+        for (Api.Client client : this.zac.keySet()) {
+            if (client.requiresGooglePlayServices()) {
+                z2 = ((zaal) this.zac.get(client)).zac;
+                if (!z2) {
+                    arrayList.add(client);
+                }
+            }
+            arrayList2.add(client);
+        }
+        int i = 0;
+        int i2 = -1;
+        if (!arrayList.isEmpty()) {
+            int size = arrayList.size();
+            while (i < size) {
+                Api.Client client2 = (Api.Client) arrayList.get(i);
+                context = this.zaa.zac;
+                i2 = zalVar.zab(context, client2);
+                i++;
+                if (i2 != 0) {
+                    break;
+                }
+            }
+        } else {
+            int size2 = arrayList2.size();
+            while (i < size2) {
+                Api.Client client3 = (Api.Client) arrayList2.get(i);
+                context3 = this.zaa.zac;
+                i2 = zalVar.zab(context3, client3);
+                i++;
+                if (i2 == 0) {
+                    break;
+                }
+            }
+        }
+        if (i2 != 0) {
+            ConnectionResult connectionResult = new ConnectionResult(i2, null);
+            zaaw zaawVar = this.zaa;
+            zabiVar2 = zaawVar.zaa;
+            zabiVar2.zal(new zaam(this, zaawVar, connectionResult));
+            return;
+        }
+        zaaw zaawVar2 = this.zaa;
+        z = zaawVar2.zam;
+        if (z) {
+            zaeVar = zaawVar2.zak;
+            if (zaeVar != null) {
+                zaeVar2 = zaawVar2.zak;
+                zaeVar2.zab();
+            }
+        }
+        for (Api.Client client4 : this.zac.keySet()) {
+            BaseGmsClient.ConnectionProgressReportCallbacks connectionProgressReportCallbacks = (BaseGmsClient.ConnectionProgressReportCallbacks) this.zac.get(client4);
+            if (client4.requiresGooglePlayServices()) {
+                context2 = this.zaa.zac;
+                if (zalVar.zab(context2, client4) != 0) {
+                    zaaw zaawVar3 = this.zaa;
+                    zabiVar = zaawVar3.zaa;
+                    zabiVar.zal(new zaan(this, zaawVar3, connectionProgressReportCallbacks));
+                }
+            }
+            client4.connect(connectionProgressReportCallbacks);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaap.java

@@ -0,0 +1,39 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.internal.IAccountAccessor;
+import java.util.ArrayList;
+
+/* loaded from: classes2.dex */
+final class zaap extends zaav {
+    final /* synthetic */ zaaw zaa;
+    private final ArrayList zac;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaap(zaaw zaawVar, ArrayList arrayList) {
+        super(zaawVar, null);
+        this.zaa = zaawVar;
+        this.zac = arrayList;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaav
+    @WorkerThread
+    public final void zaa() {
+        zabi zabiVar;
+        IAccountAccessor iAccountAccessor;
+        zabi zabiVar2;
+        zaaw zaawVar = this.zaa;
+        zabiVar = zaawVar.zaa;
+        zabiVar.zag.zad = zaaw.zao(zaawVar);
+        ArrayList arrayList = this.zac;
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            Api.Client client = (Api.Client) arrayList.get(i);
+            zaaw zaawVar2 = this.zaa;
+            iAccountAccessor = zaawVar2.zao;
+            zabiVar2 = zaawVar2.zaa;
+            client.getRemoteService(iAccountAccessor, zabiVar2.zag.zad);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaaq.java

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zaaq extends zabg {
+    final /* synthetic */ zaaw zaa;
+    final /* synthetic */ com.google.android.gms.signin.internal.zak zab;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zaaq(zaar zaarVar, zabf zabfVar, zaaw zaawVar, com.google.android.gms.signin.internal.zak zakVar) {
+        super(zabfVar);
+        this.zaa = zaawVar;
+        this.zab = zakVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabg
+    public final void zaa() {
+        zaaw.zar(this.zaa, this.zab);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaar.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.BinderThread;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+final class zaar extends com.google.android.gms.signin.internal.zac {
+    private final WeakReference zaa;
+
+    public zaar(zaaw zaawVar) {
+        this.zaa = new WeakReference(zaawVar);
+    }
+
+    @Override // com.google.android.gms.signin.internal.zac, com.google.android.gms.signin.internal.zae
+    @BinderThread
+    public final void zab(com.google.android.gms.signin.internal.zak zakVar) {
+        zabi zabiVar;
+        zaaw zaawVar = (zaaw) this.zaa.get();
+        if (zaawVar == null) {
+            return;
+        }
+        zabiVar = zaawVar.zaa;
+        zabiVar.zal(new zaaq(this, zaawVar, zaawVar, zakVar));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaat.java

@@ -0,0 +1,57 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+final class zaat implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
+    final /* synthetic */ zaaw zaa;
+
+    public /* synthetic */ zaat(zaaw zaawVar, zaas zaasVar) {
+        this.zaa = zaawVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnected(@Nullable Bundle bundle) {
+        ClientSettings clientSettings;
+        com.google.android.gms.signin.zae zaeVar;
+        clientSettings = this.zaa.zar;
+        zaeVar = this.zaa.zak;
+        ((com.google.android.gms.signin.zae) Preconditions.checkNotNull(zaeVar)).zad(new zaar(this.zaa));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.OnConnectionFailedListener
+    public final void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
+        Lock lock;
+        Lock lock2;
+        boolean zaI;
+        Lock lock3;
+        lock = this.zaa.zab;
+        lock.lock();
+        try {
+            zaI = this.zaa.zaI(connectionResult);
+            if (zaI) {
+                this.zaa.zaA();
+                this.zaa.zaF();
+            } else {
+                this.zaa.zaD(connectionResult);
+            }
+            lock3 = this.zaa.zab;
+            lock3.unlock();
+        } catch (Throwable th) {
+            lock2 = this.zaa.zab;
+            lock2.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnectionSuspended(int i) {
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaav.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.WorkerThread;
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+abstract class zaav implements Runnable {
+    final /* synthetic */ zaaw zab;
+
+    @Override // java.lang.Runnable
+    @WorkerThread
+    public final void run() {
+        Lock lock;
+        Lock lock2;
+        zabi zabiVar;
+        lock = this.zab.zab;
+        lock.lock();
+        try {
+            try {
+                if (!Thread.interrupted()) {
+                    zaa();
+                }
+            } catch (RuntimeException e) {
+                zabiVar = this.zab.zaa;
+                zabiVar.zam(e);
+            }
+        } finally {
+            lock2 = this.zab.zab;
+            lock2.unlock();
+        }
+    }
+
+    @WorkerThread
+    public abstract void zaa();
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaaw.java

@@ -0,0 +1,343 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.IAccountAccessor;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Future;
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+public final class zaaw implements zabf {
+    private final zabi zaa;
+    private final Lock zab;
+    private final Context zac;
+    private final GoogleApiAvailabilityLight zad;
+
+    @Nullable
+    private ConnectionResult zae;
+    private int zaf;
+    private int zah;
+
+    @Nullable
+    private com.google.android.gms.signin.zae zak;
+    private boolean zal;
+    private boolean zam;
+    private boolean zan;
+
+    @Nullable
+    private IAccountAccessor zao;
+    private boolean zap;
+    private boolean zaq;
+
+    @Nullable
+    private final ClientSettings zar;
+    private final Map zas;
+
+    @Nullable
+    private final Api.AbstractClientBuilder zat;
+    private int zag = 0;
+    private final Bundle zai = new Bundle();
+    private final Set zaj = new HashSet();
+    private final ArrayList zau = new ArrayList();
+
+    public zaaw(zabi zabiVar, @Nullable ClientSettings clientSettings, Map map, GoogleApiAvailabilityLight googleApiAvailabilityLight, @Nullable Api.AbstractClientBuilder abstractClientBuilder, Lock lock, Context context) {
+        this.zaa = zabiVar;
+        this.zar = clientSettings;
+        this.zas = map;
+        this.zad = googleApiAvailabilityLight;
+        this.zat = abstractClientBuilder;
+        this.zab = lock;
+        this.zac = context;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void zaA() {
+        this.zam = false;
+        this.zaa.zag.zad = Collections.emptySet();
+        for (Api.AnyClientKey anyClientKey : this.zaj) {
+            if (!this.zaa.zab.containsKey(anyClientKey)) {
+                zabi zabiVar = this.zaa;
+                zabiVar.zab.put(anyClientKey, new ConnectionResult(17, null));
+            }
+        }
+    }
+
+    private final void zaB(boolean z) {
+        com.google.android.gms.signin.zae zaeVar = this.zak;
+        if (zaeVar != null) {
+            if (zaeVar.isConnected() && z) {
+                zaeVar.zaa();
+            }
+            zaeVar.disconnect();
+            this.zao = null;
+        }
+    }
+
+    private final void zaC() {
+        this.zaa.zai();
+        zabj.zaa().execute(new zaak(this));
+        com.google.android.gms.signin.zae zaeVar = this.zak;
+        if (zaeVar != null) {
+            if (this.zap) {
+                zaeVar.zac((IAccountAccessor) Preconditions.checkNotNull(this.zao), this.zaq);
+            }
+            zaB(false);
+        }
+        Iterator it = this.zaa.zab.keySet().iterator();
+        while (it.hasNext()) {
+            ((Api.Client) Preconditions.checkNotNull((Api.Client) this.zaa.zaa.get((Api.AnyClientKey) it.next()))).disconnect();
+        }
+        this.zaa.zah.zab(this.zai.isEmpty() ? null : this.zai);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void zaD(ConnectionResult connectionResult) {
+        zaz();
+        zaB(!connectionResult.hasResolution());
+        this.zaa.zak(connectionResult);
+        this.zaa.zah.zaa(connectionResult);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void zaE(ConnectionResult connectionResult, Api api, boolean z) {
+        int priority = api.zac().getPriority();
+        if ((!z || connectionResult.hasResolution() || this.zad.getErrorResolutionIntent(connectionResult.getErrorCode()) != null) && (this.zae == null || priority < this.zaf)) {
+            this.zae = connectionResult;
+            this.zaf = priority;
+        }
+        zabi zabiVar = this.zaa;
+        zabiVar.zab.put(api.zab(), connectionResult);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void zaF() {
+        if (this.zah != 0) {
+            return;
+        }
+        if (!this.zam || this.zan) {
+            ArrayList arrayList = new ArrayList();
+            this.zag = 1;
+            this.zah = this.zaa.zaa.size();
+            for (Api.AnyClientKey anyClientKey : this.zaa.zaa.keySet()) {
+                if (!this.zaa.zab.containsKey(anyClientKey)) {
+                    arrayList.add((Api.Client) this.zaa.zaa.get(anyClientKey));
+                } else if (zaH()) {
+                    zaC();
+                }
+            }
+            if (arrayList.isEmpty()) {
+                return;
+            }
+            this.zau.add(zabj.zaa().submit(new zaap(this, arrayList)));
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean zaG(int i) {
+        if (this.zag == i) {
+            return true;
+        }
+        Log.w("GACConnecting", this.zaa.zag.zaf());
+        Log.w("GACConnecting", "Unexpected callback in ".concat(toString()));
+        Log.w("GACConnecting", "mRemainingConnections=" + this.zah);
+        Log.e("GACConnecting", "GoogleApiClient connecting is in step " + zaJ(this.zag) + " but received callback for step " + zaJ(i), new Exception());
+        zaD(new ConnectionResult(8, null));
+        return false;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean zaH() {
+        int i = this.zah - 1;
+        this.zah = i;
+        if (i > 0) {
+            return false;
+        }
+        if (i < 0) {
+            Log.w("GACConnecting", this.zaa.zag.zaf());
+            Log.wtf("GACConnecting", "GoogleApiClient received too many callbacks for the given step. Clients may be in an unexpected state; GoogleApiClient will now disconnect.", new Exception());
+            zaD(new ConnectionResult(8, null));
+            return false;
+        }
+        ConnectionResult connectionResult = this.zae;
+        if (connectionResult == null) {
+            return true;
+        }
+        this.zaa.zaf = this.zaf;
+        zaD(connectionResult);
+        return false;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final boolean zaI(ConnectionResult connectionResult) {
+        return this.zal && !connectionResult.hasResolution();
+    }
+
+    private static final String zaJ(int i) {
+        return i != 0 ? "STEP_GETTING_REMOTE_SERVICE" : "STEP_SERVICE_BINDINGS_AND_SIGN_IN";
+    }
+
+    public static /* bridge */ /* synthetic */ Set zao(zaaw zaawVar) {
+        ClientSettings clientSettings = zaawVar.zar;
+        if (clientSettings == null) {
+            return Collections.emptySet();
+        }
+        HashSet hashSet = new HashSet(clientSettings.getRequiredScopes());
+        Map zad = zaawVar.zar.zad();
+        for (Api api : zad.keySet()) {
+            zabi zabiVar = zaawVar.zaa;
+            if (!zabiVar.zab.containsKey(api.zab())) {
+                hashSet.addAll(((com.google.android.gms.common.internal.zab) zad.get(api)).zaa);
+            }
+        }
+        return hashSet;
+    }
+
+    public static /* bridge */ /* synthetic */ void zar(zaaw zaawVar, com.google.android.gms.signin.internal.zak zakVar) {
+        if (zaawVar.zaG(0)) {
+            ConnectionResult zaa = zakVar.zaa();
+            if (!zaa.isSuccess()) {
+                if (!zaawVar.zaI(zaa)) {
+                    zaawVar.zaD(zaa);
+                    return;
+                } else {
+                    zaawVar.zaA();
+                    zaawVar.zaF();
+                    return;
+                }
+            }
+            com.google.android.gms.common.internal.zav zavVar = (com.google.android.gms.common.internal.zav) Preconditions.checkNotNull(zakVar.zab());
+            ConnectionResult zaa2 = zavVar.zaa();
+            if (!zaa2.isSuccess()) {
+                String valueOf = String.valueOf(zaa2);
+                Log.wtf("GACConnecting", "Sign-in succeeded with resolve account failure: ".concat(valueOf), new Exception());
+                zaawVar.zaD(zaa2);
+                return;
+            }
+            zaawVar.zan = true;
+            zaawVar.zao = (IAccountAccessor) Preconditions.checkNotNull(zavVar.zab());
+            zaawVar.zap = zavVar.zac();
+            zaawVar.zaq = zavVar.zad();
+            zaawVar.zaF();
+        }
+    }
+
+    private final void zaz() {
+        ArrayList arrayList = this.zau;
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            ((Future) arrayList.get(i)).cancel(true);
+        }
+        this.zau.clear();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final BaseImplementation.ApiMethodImpl zaa(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        this.zaa.zag.zaa.add(apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final BaseImplementation.ApiMethodImpl zab(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        throw new IllegalStateException("GoogleApiClient is not connected yet.");
+    }
+
+    /* JADX WARN: Type inference failed for: r0v13, types: [com.google.android.gms.common.api.Api$Client, com.google.android.gms.signin.zae] */
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zad() {
+        this.zaa.zab.clear();
+        this.zam = false;
+        zaas zaasVar = null;
+        this.zae = null;
+        this.zag = 0;
+        this.zal = true;
+        this.zan = false;
+        this.zap = false;
+        HashMap hashMap = new HashMap();
+        boolean z = false;
+        for (Api api : this.zas.keySet()) {
+            Api.Client client = (Api.Client) Preconditions.checkNotNull((Api.Client) this.zaa.zaa.get(api.zab()));
+            z |= api.zac().getPriority() == 1;
+            boolean booleanValue = ((Boolean) this.zas.get(api)).booleanValue();
+            if (client.requiresSignIn()) {
+                this.zam = true;
+                if (booleanValue) {
+                    this.zaj.add(api.zab());
+                } else {
+                    this.zal = false;
+                }
+            }
+            hashMap.put(client, new zaal(this, api, booleanValue));
+        }
+        if (z) {
+            this.zam = false;
+        }
+        if (this.zam) {
+            Preconditions.checkNotNull(this.zar);
+            Preconditions.checkNotNull(this.zat);
+            this.zar.zae(Integer.valueOf(System.identityHashCode(this.zaa.zag)));
+            zaat zaatVar = new zaat(this, zaasVar);
+            Api.AbstractClientBuilder abstractClientBuilder = this.zat;
+            Context context = this.zac;
+            zabi zabiVar = this.zaa;
+            ClientSettings clientSettings = this.zar;
+            this.zak = abstractClientBuilder.buildClient(context, zabiVar.zag.getLooper(), clientSettings, (ClientSettings) clientSettings.zaa(), (GoogleApiClient.ConnectionCallbacks) zaatVar, (GoogleApiClient.OnConnectionFailedListener) zaatVar);
+        }
+        this.zah = this.zaa.zaa.size();
+        this.zau.add(zabj.zaa().submit(new zaao(this, hashMap)));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zae() {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zag(@Nullable Bundle bundle) {
+        if (zaG(1)) {
+            if (bundle != null) {
+                this.zai.putAll(bundle);
+            }
+            if (zaH()) {
+                zaC();
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zah(ConnectionResult connectionResult, Api api, boolean z) {
+        if (zaG(1)) {
+            zaE(connectionResult, api, z);
+            if (zaH()) {
+                zaC();
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zai(int i) {
+        zaD(new ConnectionResult(8, null));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final boolean zaj() {
+        zaz();
+        zaB(true);
+        this.zaa.zak(null);
+        return true;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaax.java

@@ -0,0 +1,60 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import java.util.Collections;
+import java.util.Iterator;
+
+/* loaded from: classes2.dex */
+public final class zaax implements zabf {
+    private final zabi zaa;
+
+    public zaax(zabi zabiVar) {
+        this.zaa = zabiVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final BaseImplementation.ApiMethodImpl zaa(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        this.zaa.zag.zaa.add(apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final BaseImplementation.ApiMethodImpl zab(BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        throw new IllegalStateException("GoogleApiClient is not connected yet.");
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zad() {
+        Iterator it = this.zaa.zaa.values().iterator();
+        while (it.hasNext()) {
+            ((Api.Client) it.next()).disconnect();
+        }
+        this.zaa.zag.zad = Collections.emptySet();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zae() {
+        this.zaa.zaj();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zag(@Nullable Bundle bundle) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zah(ConnectionResult connectionResult, Api api, boolean z) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zai(int i) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final boolean zaj() {
+        return true;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaay.java

@@ -0,0 +1,15 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zaay implements com.google.android.gms.common.internal.zaj {
+    final /* synthetic */ zabe zaa;
+
+    public zaay(zabe zabeVar) {
+        this.zaa = zabeVar;
+    }
+
+    @Override // com.google.android.gms.common.internal.zaj
+    public final boolean isConnected() {
+        return this.zaa.isConnected();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaaz.java

@@ -0,0 +1,29 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes2.dex */
+final class zaaz implements GoogleApiClient.ConnectionCallbacks {
+    final /* synthetic */ AtomicReference zaa;
+    final /* synthetic */ StatusPendingResult zab;
+    final /* synthetic */ zabe zac;
+
+    public zaaz(zabe zabeVar, AtomicReference atomicReference, StatusPendingResult statusPendingResult) {
+        this.zac = zabeVar;
+        this.zaa = atomicReference;
+        this.zab = statusPendingResult;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnected(@Nullable Bundle bundle) {
+        this.zac.zam((GoogleApiClient) Preconditions.checkNotNull((GoogleApiClient) this.zaa.get()), this.zab, true);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnectionSuspended(int i) {
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zab.java

@@ -0,0 +1,24 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.VisibleForTesting;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+public final class zab extends ActivityLifecycleObserver {
+    private final WeakReference zaa;
+
+    @VisibleForTesting(otherwise = 2)
+    public zab(zaa zaaVar) {
+        this.zaa = new WeakReference(zaaVar);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ActivityLifecycleObserver
+    public final ActivityLifecycleObserver onStopCallOnce(Runnable runnable) {
+        zaa zaaVar = (zaa) this.zaa.get();
+        if (zaaVar == null) {
+            throw new IllegalStateException("The target activity has already been GC'd");
+        }
+        zaaVar.zac(runnable);
+        return this;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaba.java

@@ -0,0 +1,20 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.Status;
+
+/* loaded from: classes2.dex */
+final class zaba implements GoogleApiClient.OnConnectionFailedListener {
+    final /* synthetic */ StatusPendingResult zaa;
+
+    public zaba(zabe zabeVar, StatusPendingResult statusPendingResult) {
+        this.zaa = statusPendingResult;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.OnConnectionFailedListener
+    public final void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
+        this.zaa.setResult(new Status(8));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabb.java

@@ -0,0 +1,41 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import com.google.android.gms.auth.api.signin.internal.Storage;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultCallback;
+import com.google.android.gms.common.api.Status;
+
+/* loaded from: classes2.dex */
+final class zabb implements ResultCallback {
+    final /* synthetic */ StatusPendingResult zaa;
+    final /* synthetic */ boolean zab;
+    final /* synthetic */ GoogleApiClient zac;
+    final /* synthetic */ zabe zad;
+
+    public zabb(zabe zabeVar, StatusPendingResult statusPendingResult, boolean z, GoogleApiClient googleApiClient) {
+        this.zad = zabeVar;
+        this.zaa = statusPendingResult;
+        this.zab = z;
+        this.zac = googleApiClient;
+    }
+
+    @Override // com.google.android.gms.common.api.ResultCallback
+    public final /* bridge */ /* synthetic */ void onResult(@NonNull Result result) {
+        Context context;
+        Status status = (Status) result;
+        context = this.zad.zan;
+        Storage.getInstance(context).zac();
+        if (status.isSuccess() && this.zad.isConnected()) {
+            zabe zabeVar = this.zad;
+            zabeVar.disconnect();
+            zabeVar.connect();
+        }
+        this.zaa.setResult(status);
+        if (this.zab) {
+            this.zac.disconnect();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabc.java

@@ -0,0 +1,30 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+/* loaded from: classes2.dex */
+final class zabc extends com.google.android.gms.internal.base.zau {
+    final /* synthetic */ zabe zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zabc(zabe zabeVar, Looper looper) {
+        super(looper);
+        this.zaa = zabeVar;
+    }
+
+    @Override // android.os.Handler
+    public final void handleMessage(Message message) {
+        int i = message.what;
+        if (i == 1) {
+            zabe.zaj(this.zaa);
+            return;
+        }
+        if (i == 2) {
+            zabe.zai(this.zaa);
+            return;
+        }
+        Log.w("GoogleApiClientImpl", "Unknown message id: " + i);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabd.java

@@ -0,0 +1,21 @@
+package com.google.android.gms.common.api.internal;
+
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+final class zabd extends zabw {
+    private final WeakReference zaa;
+
+    public zabd(zabe zabeVar) {
+        this.zaa = new WeakReference(zabeVar);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabw
+    public final void zaa() {
+        zabe zabeVar = (zabe) this.zaa.get();
+        if (zabeVar == null) {
+            return;
+        }
+        zabe.zai(zabeVar);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabe.java

@@ -0,0 +1,725 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.fragment.app.FragmentActivity;
+import androidx.work.WorkRequest;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.service.Common;
+import com.google.android.gms.common.util.ClientLibraryUtils;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import com.unity3d.services.UnityAdsConstants;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+public final class zabe extends GoogleApiClient implements zabz {
+
+    @Nullable
+    @VisibleForTesting
+    zabx zab;
+    final Map zac;
+    Set zad;
+    final ClientSettings zae;
+    final Map zaf;
+    final Api.AbstractClientBuilder zag;
+
+    @Nullable
+    Set zah;
+    final zadc zai;
+    private final Lock zaj;
+    private final com.google.android.gms.common.internal.zak zak;
+    private final int zam;
+    private final Context zan;
+    private final Looper zao;
+    private volatile boolean zap;
+    private long zaq;
+    private long zar;
+    private final zabc zas;
+    private final GoogleApiAvailability zat;
+    private final ListenerHolders zau;
+    private final ArrayList zav;
+    private Integer zaw;
+    private final com.google.android.gms.common.internal.zaj zax;
+
+    @Nullable
+    private zaca zal = null;
+
+    @VisibleForTesting
+    final Queue zaa = new LinkedList();
+
+    public zabe(Context context, Lock lock, Looper looper, ClientSettings clientSettings, GoogleApiAvailability googleApiAvailability, Api.AbstractClientBuilder abstractClientBuilder, Map map, List list, List list2, Map map2, int i, int i2, ArrayList arrayList) {
+        this.zaq = true != ClientLibraryUtils.isPackageSide() ? UnityAdsConstants.Timeout.INIT_TIMEOUT_MS : WorkRequest.MIN_BACKOFF_MILLIS;
+        this.zar = 5000L;
+        this.zad = new HashSet();
+        this.zau = new ListenerHolders();
+        this.zaw = null;
+        this.zah = null;
+        zaay zaayVar = new zaay(this);
+        this.zax = zaayVar;
+        this.zan = context;
+        this.zaj = lock;
+        this.zak = new com.google.android.gms.common.internal.zak(looper, zaayVar);
+        this.zao = looper;
+        this.zas = new zabc(this, looper);
+        this.zat = googleApiAvailability;
+        this.zam = i;
+        if (i >= 0) {
+            this.zaw = Integer.valueOf(i2);
+        }
+        this.zaf = map;
+        this.zac = map2;
+        this.zav = arrayList;
+        this.zai = new zadc();
+        Iterator it = list.iterator();
+        while (it.hasNext()) {
+            this.zak.zaf((GoogleApiClient.ConnectionCallbacks) it.next());
+        }
+        Iterator it2 = list2.iterator();
+        while (it2.hasNext()) {
+            this.zak.zag((GoogleApiClient.OnConnectionFailedListener) it2.next());
+        }
+        this.zae = clientSettings;
+        this.zag = abstractClientBuilder;
+    }
+
+    public static int zad(Iterable iterable, boolean z) {
+        Iterator it = iterable.iterator();
+        boolean z2 = false;
+        boolean z3 = false;
+        while (it.hasNext()) {
+            Api.Client client = (Api.Client) it.next();
+            z2 |= client.requiresSignIn();
+            z3 |= client.providesSignIn();
+        }
+        if (z2) {
+            return (z3 && z) ? 2 : 1;
+        }
+        return 3;
+    }
+
+    public static String zag(int i) {
+        return i != 1 ? i != 2 ? i != 3 ? "UNKNOWN" : "SIGN_IN_MODE_NONE" : "SIGN_IN_MODE_OPTIONAL" : "SIGN_IN_MODE_REQUIRED";
+    }
+
+    public static /* bridge */ /* synthetic */ void zai(zabe zabeVar) {
+        zabeVar.zaj.lock();
+        try {
+            if (zabeVar.zap) {
+                zabeVar.zan();
+            }
+        } finally {
+            zabeVar.zaj.unlock();
+        }
+    }
+
+    public static /* bridge */ /* synthetic */ void zaj(zabe zabeVar) {
+        zabeVar.zaj.lock();
+        try {
+            if (zabeVar.zak()) {
+                zabeVar.zan();
+            }
+        } finally {
+            zabeVar.zaj.unlock();
+        }
+    }
+
+    private final void zal(int i) {
+        Integer num = this.zaw;
+        if (num == null) {
+            this.zaw = Integer.valueOf(i);
+        } else if (num.intValue() != i) {
+            throw new IllegalStateException("Cannot use sign-in mode: " + zag(i) + ". Mode was already set to " + zag(this.zaw.intValue()));
+        }
+        if (this.zal != null) {
+            return;
+        }
+        boolean z = false;
+        boolean z2 = false;
+        for (Api.Client client : this.zac.values()) {
+            z |= client.requiresSignIn();
+            z2 |= client.providesSignIn();
+        }
+        int intValue = this.zaw.intValue();
+        if (intValue == 1) {
+            if (!z) {
+                throw new IllegalStateException("SIGN_IN_MODE_REQUIRED cannot be used on a GoogleApiClient that does not contain any authenticated APIs. Use connect() instead.");
+            }
+            if (z2) {
+                throw new IllegalStateException("Cannot use SIGN_IN_MODE_REQUIRED with GOOGLE_SIGN_IN_API. Use connect(SIGN_IN_MODE_OPTIONAL) instead.");
+            }
+        } else if (intValue == 2 && z) {
+            this.zal = zaaa.zag(this.zan, this, this.zaj, this.zao, this.zat, this.zac, this.zae, this.zaf, this.zag, this.zav);
+            return;
+        }
+        this.zal = new zabi(this.zan, this, this.zaj, this.zao, this.zat, this.zac, this.zae, this.zaf, this.zag, this.zav, this);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void zam(GoogleApiClient googleApiClient, StatusPendingResult statusPendingResult, boolean z) {
+        Common.zaa.zaa(googleApiClient).setResultCallback(new zabb(this, statusPendingResult, z, googleApiClient));
+    }
+
+    private final void zan() {
+        this.zak.zab();
+        ((zaca) Preconditions.checkNotNull(this.zal)).zaq();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    @ResultIgnorabilityUnspecified
+    public final ConnectionResult blockingConnect() {
+        boolean z = true;
+        Preconditions.checkState(Looper.myLooper() != Looper.getMainLooper(), "blockingConnect must not be called on the UI thread");
+        this.zaj.lock();
+        try {
+            if (this.zam >= 0) {
+                if (this.zaw == null) {
+                    z = false;
+                }
+                Preconditions.checkState(z, "Sign-in mode should have been set explicitly by auto-manage.");
+            } else {
+                Integer num = this.zaw;
+                if (num == null) {
+                    this.zaw = Integer.valueOf(zad(this.zac.values(), false));
+                } else if (num.intValue() == 2) {
+                    throw new IllegalStateException("Cannot call blockingConnect() when sign-in mode is set to SIGN_IN_MODE_OPTIONAL. Call connect(SIGN_IN_MODE_OPTIONAL) instead.");
+                }
+            }
+            zal(((Integer) Preconditions.checkNotNull(this.zaw)).intValue());
+            this.zak.zab();
+            ConnectionResult zab = ((zaca) Preconditions.checkNotNull(this.zal)).zab();
+            this.zaj.unlock();
+            return zab;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final PendingResult<Status> clearDefaultAccountAndReconnect() {
+        Preconditions.checkState(isConnected(), "GoogleApiClient is not connected yet.");
+        Integer num = this.zaw;
+        boolean z = true;
+        if (num != null && num.intValue() == 2) {
+            z = false;
+        }
+        Preconditions.checkState(z, "Cannot use clearDefaultAccountAndReconnect with GOOGLE_SIGN_IN_API");
+        StatusPendingResult statusPendingResult = new StatusPendingResult(this);
+        if (this.zac.containsKey(Common.CLIENT_KEY)) {
+            zam(this, statusPendingResult, false);
+        } else {
+            AtomicReference atomicReference = new AtomicReference();
+            zaaz zaazVar = new zaaz(this, atomicReference, statusPendingResult);
+            zaba zabaVar = new zaba(this, statusPendingResult);
+            GoogleApiClient.Builder builder = new GoogleApiClient.Builder(this.zan);
+            builder.addApi(Common.API);
+            builder.addConnectionCallbacks(zaazVar);
+            builder.addOnConnectionFailedListener(zabaVar);
+            builder.setHandler(this.zas);
+            GoogleApiClient build = builder.build();
+            atomicReference.set(build);
+            build.connect();
+        }
+        return statusPendingResult;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void connect() {
+        this.zaj.lock();
+        try {
+            int i = 2;
+            boolean z = false;
+            if (this.zam >= 0) {
+                Preconditions.checkState(this.zaw != null, "Sign-in mode should have been set explicitly by auto-manage.");
+            } else {
+                Integer num = this.zaw;
+                if (num == null) {
+                    this.zaw = Integer.valueOf(zad(this.zac.values(), false));
+                } else if (num.intValue() == 2) {
+                    throw new IllegalStateException("Cannot call connect() when SignInMode is set to SIGN_IN_MODE_OPTIONAL. Call connect(SIGN_IN_MODE_OPTIONAL) instead.");
+                }
+            }
+            int intValue = ((Integer) Preconditions.checkNotNull(this.zaw)).intValue();
+            this.zaj.lock();
+            try {
+                if (intValue == 3 || intValue == 1) {
+                    i = intValue;
+                } else if (intValue != 2) {
+                    i = intValue;
+                    Preconditions.checkArgument(z, "Illegal sign-in mode: " + i);
+                    zal(i);
+                    zan();
+                    this.zaj.unlock();
+                    return;
+                }
+                Preconditions.checkArgument(z, "Illegal sign-in mode: " + i);
+                zal(i);
+                zan();
+                this.zaj.unlock();
+                return;
+            } finally {
+                this.zaj.unlock();
+            }
+            z = true;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void disconnect() {
+        this.zaj.lock();
+        try {
+            this.zai.zab();
+            zaca zacaVar = this.zal;
+            if (zacaVar != null) {
+                zacaVar.zar();
+            }
+            this.zau.zab();
+            for (BaseImplementation.ApiMethodImpl apiMethodImpl : this.zaa) {
+                apiMethodImpl.zan(null);
+                apiMethodImpl.cancel();
+            }
+            this.zaa.clear();
+            if (this.zal != null) {
+                zak();
+                this.zak.zaa();
+            }
+            this.zaj.unlock();
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void dump(String str, @Nullable FileDescriptor fileDescriptor, PrintWriter printWriter, @Nullable String[] strArr) {
+        printWriter.append((CharSequence) str).append("mContext=").println(this.zan);
+        printWriter.append((CharSequence) str).append("mResuming=").print(this.zap);
+        printWriter.append(" mWorkQueue.size()=").print(this.zaa.size());
+        printWriter.append(" mUnconsumedApiCalls.size()=").println(this.zai.zab.size());
+        zaca zacaVar = this.zal;
+        if (zacaVar != null) {
+            zacaVar.zas(str, fileDescriptor, printWriter, strArr);
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    @ResultIgnorabilityUnspecified
+    public final <A extends Api.AnyClient, R extends Result, T extends BaseImplementation.ApiMethodImpl<R, A>> T enqueue(@NonNull T t) {
+        Api<?> api = t.getApi();
+        Preconditions.checkArgument(this.zac.containsKey(t.getClientKey()), "GoogleApiClient is not configured to use " + (api != null ? api.zad() : "the API") + " required for this call.");
+        this.zaj.lock();
+        try {
+            zaca zacaVar = this.zal;
+            if (zacaVar == null) {
+                this.zaa.add(t);
+            } else {
+                t = (T) zacaVar.zae(t);
+            }
+            this.zaj.unlock();
+            return t;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    @ResultIgnorabilityUnspecified
+    public final <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T execute(@NonNull T t) {
+        Map map = this.zac;
+        Api<?> api = t.getApi();
+        Preconditions.checkArgument(map.containsKey(t.getClientKey()), "GoogleApiClient is not configured to use " + (api != null ? api.zad() : "the API") + " required for this call.");
+        this.zaj.lock();
+        try {
+            zaca zacaVar = this.zal;
+            if (zacaVar == null) {
+                throw new IllegalStateException("GoogleApiClient is not connected yet.");
+            }
+            if (this.zap) {
+                this.zaa.add(t);
+                while (!this.zaa.isEmpty()) {
+                    BaseImplementation.ApiMethodImpl apiMethodImpl = (BaseImplementation.ApiMethodImpl) this.zaa.remove();
+                    this.zai.zaa(apiMethodImpl);
+                    apiMethodImpl.setFailedResult(Status.RESULT_INTERNAL_ERROR);
+                }
+            } else {
+                t = (T) zacaVar.zaf(t);
+            }
+            this.zaj.unlock();
+            return t;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    @NonNull
+    public final <C extends Api.Client> C getClient(@NonNull Api.AnyClientKey<C> anyClientKey) {
+        C c = (C) this.zac.get(anyClientKey);
+        Preconditions.checkNotNull(c, "Appropriate Api was not requested.");
+        return c;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    @NonNull
+    public final ConnectionResult getConnectionResult(@NonNull Api<?> api) {
+        ConnectionResult connectionResult;
+        this.zaj.lock();
+        try {
+            if (!isConnected() && !this.zap) {
+                throw new IllegalStateException("Cannot invoke getConnectionResult unless GoogleApiClient is connected");
+            }
+            if (!this.zac.containsKey(api.zab())) {
+                throw new IllegalArgumentException(api.zad() + " was never registered with GoogleApiClient");
+            }
+            ConnectionResult zad = ((zaca) Preconditions.checkNotNull(this.zal)).zad(api);
+            if (zad != null) {
+                this.zaj.unlock();
+                return zad;
+            }
+            if (this.zap) {
+                connectionResult = ConnectionResult.RESULT_SUCCESS;
+            } else {
+                Log.w("GoogleApiClientImpl", zaf());
+                Log.wtf("GoogleApiClientImpl", api.zad() + " requested in getConnectionResult is not connected but is not present in the failed  connections map", new Exception());
+                connectionResult = new ConnectionResult(8, null);
+            }
+            this.zaj.unlock();
+            return connectionResult;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final Context getContext() {
+        return this.zan;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final Looper getLooper() {
+        return this.zao;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean hasApi(@NonNull Api<?> api) {
+        return this.zac.containsKey(api.zab());
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean hasConnectedApi(@NonNull Api<?> api) {
+        Api.Client client;
+        return isConnected() && (client = (Api.Client) this.zac.get(api.zab())) != null && client.isConnected();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnected() {
+        zaca zacaVar = this.zal;
+        return zacaVar != null && zacaVar.zaw();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnecting() {
+        zaca zacaVar = this.zal;
+        return zacaVar != null && zacaVar.zax();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnectionCallbacksRegistered(@NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        return this.zak.zaj(connectionCallbacks);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnectionFailedListenerRegistered(@NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        return this.zak.zak(onConnectionFailedListener);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean maybeSignIn(SignInConnectionListener signInConnectionListener) {
+        zaca zacaVar = this.zal;
+        return zacaVar != null && zacaVar.zay(signInConnectionListener);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void maybeSignOut() {
+        zaca zacaVar = this.zal;
+        if (zacaVar != null) {
+            zacaVar.zau();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void reconnect() {
+        disconnect();
+        connect();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void registerConnectionCallbacks(@NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        this.zak.zaf(connectionCallbacks);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void registerConnectionFailedListener(@NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        this.zak.zag(onConnectionFailedListener);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final <L> ListenerHolder<L> registerListener(@NonNull L l) {
+        this.zaj.lock();
+        try {
+            return this.zau.zaa(l, this.zao, "NO_TYPE");
+        } finally {
+            this.zaj.unlock();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void stopAutoManage(@NonNull FragmentActivity fragmentActivity) {
+        LifecycleActivity lifecycleActivity = new LifecycleActivity((Activity) fragmentActivity);
+        if (this.zam < 0) {
+            throw new IllegalStateException("Called stopAutoManage but automatic lifecycle management is not enabled.");
+        }
+        zak.zaa(lifecycleActivity).zae(this.zam);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionCallbacks(@NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        this.zak.zah(connectionCallbacks);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionFailedListener(@NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        this.zak.zai(onConnectionFailedListener);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabz
+    public final void zaa(ConnectionResult connectionResult) {
+        if (!this.zat.isPlayServicesPossiblyUpdating(this.zan, connectionResult.getErrorCode())) {
+            zak();
+        }
+        if (this.zap) {
+            return;
+        }
+        this.zak.zac(connectionResult);
+        this.zak.zaa();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabz
+    public final void zab(@Nullable Bundle bundle) {
+        while (!this.zaa.isEmpty()) {
+            execute((BaseImplementation.ApiMethodImpl) this.zaa.remove());
+        }
+        this.zak.zad(bundle);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabz
+    public final void zac(int i, boolean z) {
+        if (i == 1) {
+            if (!z && !this.zap) {
+                this.zap = true;
+                if (this.zab == null && !ClientLibraryUtils.isPackageSide()) {
+                    try {
+                        this.zab = this.zat.zac(this.zan.getApplicationContext(), new zabd(this));
+                    } catch (SecurityException unused) {
+                    }
+                }
+                zabc zabcVar = this.zas;
+                zabcVar.sendMessageDelayed(zabcVar.obtainMessage(1), this.zaq);
+                zabc zabcVar2 = this.zas;
+                zabcVar2.sendMessageDelayed(zabcVar2.obtainMessage(2), this.zar);
+            }
+            i = 1;
+        }
+        for (BasePendingResult basePendingResult : (BasePendingResult[]) this.zai.zab.toArray(new BasePendingResult[0])) {
+            basePendingResult.forceFailureUnlessReady(zadc.zaa);
+        }
+        this.zak.zae(i);
+        this.zak.zaa();
+        if (i == 2) {
+            zan();
+        }
+    }
+
+    public final String zaf() {
+        StringWriter stringWriter = new StringWriter();
+        dump("", null, new PrintWriter(stringWriter), null);
+        return stringWriter.toString();
+    }
+
+    @ResultIgnorabilityUnspecified
+    public final boolean zak() {
+        if (!this.zap) {
+            return false;
+        }
+        this.zap = false;
+        this.zas.removeMessages(2);
+        this.zas.removeMessages(1);
+        zabx zabxVar = this.zab;
+        if (zabxVar != null) {
+            zabxVar.zab();
+            this.zab = null;
+        }
+        return true;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void zao(zada zadaVar) {
+        this.zaj.lock();
+        try {
+            if (this.zah == null) {
+                this.zah = new HashSet();
+            }
+            this.zah.add(zadaVar);
+            this.zaj.unlock();
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:24:0x0043, code lost:
+    
+        if (r3 == false) goto L21;
+     */
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void zap(com.google.android.gms.common.api.internal.zada r3) {
+        /*
+            r2 = this;
+            java.util.concurrent.locks.Lock r0 = r2.zaj
+            r0.lock()
+            java.util.Set r0 = r2.zah     // Catch: java.lang.Throwable -> L16
+            java.lang.String r1 = "GoogleApiClientImpl"
+            if (r0 != 0) goto L18
+            java.lang.String r3 = "Attempted to remove pending transform when no transforms are registered."
+            java.lang.Exception r0 = new java.lang.Exception     // Catch: java.lang.Throwable -> L16
+            r0.<init>()     // Catch: java.lang.Throwable -> L16
+            android.util.Log.wtf(r1, r3, r0)     // Catch: java.lang.Throwable -> L16
+            goto L4c
+        L16:
+            r3 = move-exception
+            goto L59
+        L18:
+            boolean r3 = r0.remove(r3)     // Catch: java.lang.Throwable -> L16
+            if (r3 != 0) goto L29
+            java.lang.String r3 = "Failed to remove pending transform - this may lead to memory leaks!"
+            java.lang.Exception r0 = new java.lang.Exception     // Catch: java.lang.Throwable -> L16
+            r0.<init>()     // Catch: java.lang.Throwable -> L16
+            android.util.Log.wtf(r1, r3, r0)     // Catch: java.lang.Throwable -> L16
+            goto L4c
+        L29:
+            java.util.concurrent.locks.Lock r3 = r2.zaj     // Catch: java.lang.Throwable -> L16
+            r3.lock()     // Catch: java.lang.Throwable -> L16
+            java.util.Set r3 = r2.zah     // Catch: java.lang.Throwable -> L52
+            if (r3 != 0) goto L38
+            java.util.concurrent.locks.Lock r3 = r2.zaj     // Catch: java.lang.Throwable -> L16
+            r3.unlock()     // Catch: java.lang.Throwable -> L16
+            goto L45
+        L38:
+            boolean r3 = r3.isEmpty()     // Catch: java.lang.Throwable -> L52
+            r3 = r3 ^ 1
+            java.util.concurrent.locks.Lock r0 = r2.zaj     // Catch: java.lang.Throwable -> L16
+            r0.unlock()     // Catch: java.lang.Throwable -> L16
+            if (r3 != 0) goto L4c
+        L45:
+            com.google.android.gms.common.api.internal.zaca r3 = r2.zal     // Catch: java.lang.Throwable -> L16
+            if (r3 == 0) goto L4c
+            r3.zat()     // Catch: java.lang.Throwable -> L16
+        L4c:
+            java.util.concurrent.locks.Lock r3 = r2.zaj
+            r3.unlock()
+            return
+        L52:
+            r3 = move-exception
+            java.util.concurrent.locks.Lock r0 = r2.zaj     // Catch: java.lang.Throwable -> L16
+            r0.unlock()     // Catch: java.lang.Throwable -> L16
+            throw r3     // Catch: java.lang.Throwable -> L16
+        L59:
+            java.util.concurrent.locks.Lock r0 = r2.zaj
+            r0.unlock()
+            throw r3
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.api.internal.zabe.zap(com.google.android.gms.common.api.internal.zada):void");
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final ConnectionResult blockingConnect(long j, @NonNull TimeUnit timeUnit) {
+        Preconditions.checkState(Looper.myLooper() != Looper.getMainLooper(), "blockingConnect must not be called on the UI thread");
+        Preconditions.checkNotNull(timeUnit, "TimeUnit must not be null");
+        this.zaj.lock();
+        try {
+            Integer num = this.zaw;
+            if (num != null) {
+                if (num.intValue() == 2) {
+                    throw new IllegalStateException("Cannot call blockingConnect() when sign-in mode is set to SIGN_IN_MODE_OPTIONAL. Call connect(SIGN_IN_MODE_OPTIONAL) instead.");
+                }
+            } else {
+                this.zaw = Integer.valueOf(zad(this.zac.values(), false));
+            }
+            zal(((Integer) Preconditions.checkNotNull(this.zaw)).intValue());
+            this.zak.zab();
+            ConnectionResult zac = ((zaca) Preconditions.checkNotNull(this.zal)).zac(j, timeUnit);
+            this.zaj.unlock();
+            return zac;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void connect(int i) {
+        this.zaj.lock();
+        boolean z = true;
+        if (i != 3 && i != 1) {
+            if (i == 2) {
+                i = 2;
+            } else {
+                z = false;
+            }
+        }
+        try {
+            Preconditions.checkArgument(z, "Illegal sign-in mode: " + i);
+            zal(i);
+            zan();
+        } finally {
+            this.zaj.unlock();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabf.java

@@ -0,0 +1,26 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+
+/* loaded from: classes2.dex */
+public interface zabf {
+    BaseImplementation.ApiMethodImpl zaa(BaseImplementation.ApiMethodImpl apiMethodImpl);
+
+    BaseImplementation.ApiMethodImpl zab(BaseImplementation.ApiMethodImpl apiMethodImpl);
+
+    void zad();
+
+    void zae();
+
+    void zag(@Nullable Bundle bundle);
+
+    void zah(ConnectionResult connectionResult, Api api, boolean z);
+
+    void zai(int i);
+
+    boolean zaj();
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabg.java

@@ -0,0 +1,31 @@
+package com.google.android.gms.common.api.internal;
+
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+abstract class zabg {
+    private final zabf zaa;
+
+    public zabg(zabf zabfVar) {
+        this.zaa = zabfVar;
+    }
+
+    public abstract void zaa();
+
+    public final void zab(zabi zabiVar) {
+        Lock lock;
+        Lock lock2;
+        zabf zabfVar;
+        lock = zabiVar.zai;
+        lock.lock();
+        try {
+            zabfVar = zabiVar.zan;
+            if (zabfVar == this.zaa) {
+                zaa();
+            }
+        } finally {
+            lock2 = zabiVar.zai;
+            lock2.unlock();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabh.java

@@ -0,0 +1,29 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+/* loaded from: classes2.dex */
+final class zabh extends com.google.android.gms.internal.base.zau {
+    final /* synthetic */ zabi zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zabh(zabi zabiVar, Looper looper) {
+        super(looper);
+        this.zaa = zabiVar;
+    }
+
+    @Override // android.os.Handler
+    public final void handleMessage(Message message) {
+        int i = message.what;
+        if (i == 1) {
+            ((zabg) message.obj).zab(this.zaa);
+        } else {
+            if (i == 2) {
+                throw ((RuntimeException) message.obj);
+            }
+            Log.w("GACStateManager", "Unknown message id: " + i);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabi.java

@@ -0,0 +1,262 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.internal.security.CertificateUtil;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.Preconditions;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes2.dex */
+public final class zabi implements zaca, zau {
+    final Map zaa;
+
+    @Nullable
+    final ClientSettings zac;
+    final Map zad;
+
+    @Nullable
+    final Api.AbstractClientBuilder zae;
+    int zaf;
+    final zabe zag;
+    final zabz zah;
+    private final Lock zai;
+    private final Condition zaj;
+    private final Context zak;
+    private final GoogleApiAvailabilityLight zal;
+    private final zabh zam;
+    private volatile zabf zan;
+    final Map zab = new HashMap();
+
+    @Nullable
+    private ConnectionResult zao = null;
+
+    public zabi(Context context, zabe zabeVar, Lock lock, Looper looper, GoogleApiAvailabilityLight googleApiAvailabilityLight, Map map, @Nullable ClientSettings clientSettings, Map map2, @Nullable Api.AbstractClientBuilder abstractClientBuilder, ArrayList arrayList, zabz zabzVar) {
+        this.zak = context;
+        this.zai = lock;
+        this.zal = googleApiAvailabilityLight;
+        this.zaa = map;
+        this.zac = clientSettings;
+        this.zad = map2;
+        this.zae = abstractClientBuilder;
+        this.zag = zabeVar;
+        this.zah = zabzVar;
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            ((zat) arrayList.get(i)).zaa(this);
+        }
+        this.zam = new zabh(this, looper);
+        this.zaj = lock.newCondition();
+        this.zan = new zaax(this);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnected(@Nullable Bundle bundle) {
+        this.zai.lock();
+        try {
+            this.zan.zag(bundle);
+        } finally {
+            this.zai.unlock();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnectionSuspended(int i) {
+        this.zai.lock();
+        try {
+            this.zan.zai(i);
+        } finally {
+            this.zai.unlock();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zau
+    public final void zaa(@NonNull ConnectionResult connectionResult, @NonNull Api api, boolean z) {
+        this.zai.lock();
+        try {
+            this.zan.zah(connectionResult, api, z);
+        } finally {
+            this.zai.unlock();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final ConnectionResult zab() {
+        zaq();
+        while (this.zan instanceof zaaw) {
+            try {
+                this.zaj.await();
+            } catch (InterruptedException unused) {
+                Thread.currentThread().interrupt();
+                return new ConnectionResult(15, null);
+            }
+        }
+        if (this.zan instanceof zaaj) {
+            return ConnectionResult.RESULT_SUCCESS;
+        }
+        ConnectionResult connectionResult = this.zao;
+        return connectionResult != null ? connectionResult : new ConnectionResult(13, null);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final ConnectionResult zac(long j, TimeUnit timeUnit) {
+        zaq();
+        long nanos = timeUnit.toNanos(j);
+        while (this.zan instanceof zaaw) {
+            if (nanos <= 0) {
+                zar();
+                return new ConnectionResult(14, null);
+            }
+            try {
+                nanos = this.zaj.awaitNanos(nanos);
+            } catch (InterruptedException unused) {
+                Thread.currentThread().interrupt();
+                return new ConnectionResult(15, null);
+            }
+            Thread.currentThread().interrupt();
+            return new ConnectionResult(15, null);
+        }
+        if (this.zan instanceof zaaj) {
+            return ConnectionResult.RESULT_SUCCESS;
+        }
+        ConnectionResult connectionResult = this.zao;
+        return connectionResult != null ? connectionResult : new ConnectionResult(13, null);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    @Nullable
+    public final ConnectionResult zad(@NonNull Api api) {
+        Map map = this.zaa;
+        Api.AnyClientKey zab = api.zab();
+        if (!map.containsKey(zab)) {
+            return null;
+        }
+        if (((Api.Client) this.zaa.get(zab)).isConnected()) {
+            return ConnectionResult.RESULT_SUCCESS;
+        }
+        if (this.zab.containsKey(zab)) {
+            return (ConnectionResult) this.zab.get(zab);
+        }
+        return null;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final BaseImplementation.ApiMethodImpl zae(@NonNull BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        apiMethodImpl.zak();
+        this.zan.zaa(apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final BaseImplementation.ApiMethodImpl zaf(@NonNull BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        apiMethodImpl.zak();
+        return this.zan.zab(apiMethodImpl);
+    }
+
+    public final void zai() {
+        this.zai.lock();
+        try {
+            this.zag.zak();
+            this.zan = new zaaj(this);
+            this.zan.zad();
+            this.zaj.signalAll();
+        } finally {
+            this.zai.unlock();
+        }
+    }
+
+    public final void zaj() {
+        this.zai.lock();
+        try {
+            this.zan = new zaaw(this, this.zac, this.zad, this.zal, this.zae, this.zai, this.zak);
+            this.zan.zad();
+            this.zaj.signalAll();
+        } finally {
+            this.zai.unlock();
+        }
+    }
+
+    public final void zak(@Nullable ConnectionResult connectionResult) {
+        this.zai.lock();
+        try {
+            this.zao = connectionResult;
+            this.zan = new zaax(this);
+            this.zan.zad();
+            this.zaj.signalAll();
+        } finally {
+            this.zai.unlock();
+        }
+    }
+
+    public final void zal(zabg zabgVar) {
+        zabh zabhVar = this.zam;
+        zabhVar.sendMessage(zabhVar.obtainMessage(1, zabgVar));
+    }
+
+    public final void zam(RuntimeException runtimeException) {
+        zabh zabhVar = this.zam;
+        zabhVar.sendMessage(zabhVar.obtainMessage(2, runtimeException));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zaq() {
+        this.zan.zae();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zar() {
+        if (this.zan.zaj()) {
+            this.zab.clear();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zas(String str, @Nullable FileDescriptor fileDescriptor, PrintWriter printWriter, @Nullable String[] strArr) {
+        printWriter.append((CharSequence) str).append("mState=").println(this.zan);
+        for (Api api : this.zad.keySet()) {
+            String valueOf = String.valueOf(str);
+            printWriter.append((CharSequence) str).append((CharSequence) api.zad()).println(CertificateUtil.DELIMITER);
+            ((Api.Client) Preconditions.checkNotNull((Api.Client) this.zaa.get(api.zab()))).dump(valueOf.concat("  "), fileDescriptor, printWriter, strArr);
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zat() {
+        if (this.zan instanceof zaaj) {
+            ((zaaj) this.zan).zaf();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final void zau() {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final boolean zaw() {
+        return this.zan instanceof zaaj;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final boolean zax() {
+        return this.zan instanceof zaaw;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final boolean zay(SignInConnectionListener signInConnectionListener) {
+        return false;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabj.java

@@ -0,0 +1,13 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.util.concurrent.NumberedThreadFactory;
+import java.util.concurrent.ExecutorService;
+
+/* loaded from: classes2.dex */
+public final class zabj {
+    private static final ExecutorService zaa = com.google.android.gms.internal.base.zat.zaa().zac(2, new NumberedThreadFactory("GAC_Executor"), 2);
+
+    public static ExecutorService zaa() {
+        return zaa;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabl.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.api.internal.BackgroundDetector;
+
+/* loaded from: classes2.dex */
+final class zabl implements BackgroundDetector.BackgroundStateChangeListener {
+    final /* synthetic */ GoogleApiManager zaa;
+
+    public zabl(GoogleApiManager googleApiManager) {
+        this.zaa = googleApiManager;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.BackgroundDetector.BackgroundStateChangeListener
+    public final void onBackgroundStateChanged(boolean z) {
+        GoogleApiManager googleApiManager = this.zaa;
+        googleApiManager.zar.sendMessage(googleApiManager.zar.obtainMessage(1, Boolean.valueOf(z)));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabm.java

@@ -0,0 +1,15 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zabm implements Runnable {
+    final /* synthetic */ zabq zaa;
+
+    public zabm(zabq zabqVar) {
+        this.zaa = zabqVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        this.zaa.zaH();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabn.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zabn implements Runnable {
+    final /* synthetic */ int zaa;
+    final /* synthetic */ zabq zab;
+
+    public zabn(zabq zabqVar, int i) {
+        this.zab = zabqVar;
+        this.zaa = i;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        this.zab.zaI(this.zaa);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabo.java

@@ -0,0 +1,22 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.api.Api;
+
+/* loaded from: classes2.dex */
+final class zabo implements Runnable {
+    final /* synthetic */ zabp zaa;
+
+    public zabo(zabp zabpVar) {
+        this.zaa = zabpVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Api.Client client;
+        Api.Client client2;
+        zabq zabqVar = this.zaa.zaa;
+        client = zabqVar.zac;
+        client2 = zabqVar.zac;
+        client.disconnect(client2.getClass().getName().concat(" disconnecting because it was signed out."));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabp.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.internal.BaseGmsClient;
+
+/* loaded from: classes2.dex */
+final class zabp implements BaseGmsClient.SignOutCallbacks {
+    final /* synthetic */ zabq zaa;
+
+    public zabp(zabq zabqVar) {
+        this.zaa = zabqVar;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient.SignOutCallbacks
+    public final void onSignOutComplete() {
+        this.zaa.zaa.zar.post(new zabo(this));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabq.java

@@ -0,0 +1,550 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import android.os.DeadObjectException;
+import android.os.Looper;
+import android.os.Message;
+import android.os.RemoteException;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+import androidx.collection.ArrayMap;
+import androidx.work.PeriodicWorkRequest;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApi;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.UnsupportedApiCallException;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.ArrayUtils;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import com.unity3d.services.UnityAdsConstants;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class zabq implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, zau {
+    final /* synthetic */ GoogleApiManager zaa;
+    private final Api.Client zac;
+    private final ApiKey zad;
+    private final zaad zae;
+    private final int zah;
+
+    @Nullable
+    private final zact zai;
+    private boolean zaj;
+    private final Queue zab = new LinkedList();
+    private final Set zaf = new HashSet();
+    private final Map zag = new HashMap();
+    private final List zak = new ArrayList();
+
+    @Nullable
+    private ConnectionResult zal = null;
+    private int zam = 0;
+
+    @WorkerThread
+    public zabq(GoogleApiManager googleApiManager, GoogleApi googleApi) {
+        this.zaa = googleApiManager;
+        Api.Client zab = googleApi.zab(googleApiManager.zar.getLooper(), this);
+        this.zac = zab;
+        this.zad = googleApi.getApiKey();
+        this.zae = new zaad();
+        this.zah = googleApi.zaa();
+        if (zab.requiresSignIn()) {
+            this.zai = googleApi.zac(googleApiManager.zai, googleApiManager.zar);
+        } else {
+            this.zai = null;
+        }
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Nullable
+    @WorkerThread
+    private final Feature zaC(@Nullable Feature[] featureArr) {
+        if (featureArr != null && featureArr.length != 0) {
+            Feature[] availableFeatures = this.zac.getAvailableFeatures();
+            if (availableFeatures == null) {
+                availableFeatures = new Feature[0];
+            }
+            ArrayMap arrayMap = new ArrayMap(availableFeatures.length);
+            for (Feature feature : availableFeatures) {
+                arrayMap.put(feature.getName(), Long.valueOf(feature.getVersion()));
+            }
+            for (Feature feature2 : featureArr) {
+                Long l = (Long) arrayMap.get(feature2.getName());
+                if (l == null || l.longValue() < feature2.getVersion()) {
+                    return feature2;
+                }
+            }
+        }
+        return null;
+    }
+
+    @WorkerThread
+    private final void zaD(ConnectionResult connectionResult) {
+        Iterator it = this.zaf.iterator();
+        while (it.hasNext()) {
+            ((zal) it.next()).zac(this.zad, connectionResult, Objects.equal(connectionResult, ConnectionResult.RESULT_SUCCESS) ? this.zac.getEndpointPackageName() : null);
+        }
+        this.zaf.clear();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @WorkerThread
+    public final void zaE(Status status) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        zaF(status, null, false);
+    }
+
+    @WorkerThread
+    private final void zaF(@Nullable Status status, @Nullable Exception exc, boolean z) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        if ((status == null) == (exc == null)) {
+            throw new IllegalArgumentException("Status XOR exception should be null");
+        }
+        Iterator it = this.zab.iterator();
+        while (it.hasNext()) {
+            zai zaiVar = (zai) it.next();
+            if (!z || zaiVar.zac == 2) {
+                if (status != null) {
+                    zaiVar.zad(status);
+                } else {
+                    zaiVar.zae(exc);
+                }
+                it.remove();
+            }
+        }
+    }
+
+    @WorkerThread
+    private final void zaG() {
+        ArrayList arrayList = new ArrayList(this.zab);
+        int size = arrayList.size();
+        for (int i = 0; i < size; i++) {
+            zai zaiVar = (zai) arrayList.get(i);
+            if (!this.zac.isConnected()) {
+                return;
+            }
+            if (zaM(zaiVar)) {
+                this.zab.remove(zaiVar);
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @WorkerThread
+    public final void zaH() {
+        zan();
+        zaD(ConnectionResult.RESULT_SUCCESS);
+        zaL();
+        Iterator it = this.zag.values().iterator();
+        while (it.hasNext()) {
+            zaci zaciVar = (zaci) it.next();
+            if (zaC(zaciVar.zaa.getRequiredFeatures()) != null) {
+                it.remove();
+            } else {
+                try {
+                    zaciVar.zaa.registerListener(this.zac, new TaskCompletionSource<>());
+                } catch (DeadObjectException unused) {
+                    onConnectionSuspended(3);
+                    this.zac.disconnect("DeadObjectException thrown while calling register listener method.");
+                } catch (RemoteException unused2) {
+                    it.remove();
+                }
+            }
+        }
+        zaG();
+        zaJ();
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @WorkerThread
+    public final void zaI(int i) {
+        zan();
+        this.zaj = true;
+        this.zae.zae(i, this.zac.getLastDisconnectMessage());
+        ApiKey apiKey = this.zad;
+        GoogleApiManager googleApiManager = this.zaa;
+        googleApiManager.zar.sendMessageDelayed(Message.obtain(googleApiManager.zar, 9, apiKey), 5000L);
+        ApiKey apiKey2 = this.zad;
+        GoogleApiManager googleApiManager2 = this.zaa;
+        googleApiManager2.zar.sendMessageDelayed(Message.obtain(googleApiManager2.zar, 11, apiKey2), UnityAdsConstants.Timeout.INIT_TIMEOUT_MS);
+        this.zaa.zak.zac();
+        Iterator it = this.zag.values().iterator();
+        while (it.hasNext()) {
+            ((zaci) it.next()).zac.run();
+        }
+    }
+
+    private final void zaJ() {
+        this.zaa.zar.removeMessages(12, this.zad);
+        ApiKey apiKey = this.zad;
+        GoogleApiManager googleApiManager = this.zaa;
+        googleApiManager.zar.sendMessageDelayed(googleApiManager.zar.obtainMessage(12, apiKey), this.zaa.zae);
+    }
+
+    @WorkerThread
+    private final void zaK(zai zaiVar) {
+        zaiVar.zag(this.zae, zaA());
+        try {
+            zaiVar.zaf(this);
+        } catch (DeadObjectException unused) {
+            onConnectionSuspended(1);
+            this.zac.disconnect("DeadObjectException thrown while running ApiCallRunner.");
+        }
+    }
+
+    @WorkerThread
+    private final void zaL() {
+        if (this.zaj) {
+            GoogleApiManager googleApiManager = this.zaa;
+            googleApiManager.zar.removeMessages(11, this.zad);
+            GoogleApiManager googleApiManager2 = this.zaa;
+            googleApiManager2.zar.removeMessages(9, this.zad);
+            this.zaj = false;
+        }
+    }
+
+    @WorkerThread
+    private final boolean zaM(zai zaiVar) {
+        if (!(zaiVar instanceof zac)) {
+            zaK(zaiVar);
+            return true;
+        }
+        zac zacVar = (zac) zaiVar;
+        Feature zaC = zaC(zacVar.zab(this));
+        if (zaC == null) {
+            zaK(zaiVar);
+            return true;
+        }
+        Log.w("GoogleApiManager", this.zac.getClass().getName() + " could not execute call because it requires feature (" + zaC.getName() + ", " + zaC.getVersion() + ").");
+        if (!this.zaa.zas || !zacVar.zaa(this)) {
+            zacVar.zae(new UnsupportedApiCallException(zaC));
+            return true;
+        }
+        zabs zabsVar = new zabs(this.zad, zaC, null);
+        int indexOf = this.zak.indexOf(zabsVar);
+        if (indexOf >= 0) {
+            zabs zabsVar2 = (zabs) this.zak.get(indexOf);
+            this.zaa.zar.removeMessages(15, zabsVar2);
+            GoogleApiManager googleApiManager = this.zaa;
+            googleApiManager.zar.sendMessageDelayed(Message.obtain(googleApiManager.zar, 15, zabsVar2), 5000L);
+            return false;
+        }
+        this.zak.add(zabsVar);
+        GoogleApiManager googleApiManager2 = this.zaa;
+        googleApiManager2.zar.sendMessageDelayed(Message.obtain(googleApiManager2.zar, 15, zabsVar), 5000L);
+        GoogleApiManager googleApiManager3 = this.zaa;
+        googleApiManager3.zar.sendMessageDelayed(Message.obtain(googleApiManager3.zar, 16, zabsVar), UnityAdsConstants.Timeout.INIT_TIMEOUT_MS);
+        ConnectionResult connectionResult = new ConnectionResult(2, null);
+        if (zaN(connectionResult)) {
+            return false;
+        }
+        this.zaa.zaE(connectionResult, this.zah);
+        return false;
+    }
+
+    @WorkerThread
+    private final boolean zaN(@NonNull ConnectionResult connectionResult) {
+        synchronized (GoogleApiManager.zac) {
+            try {
+                GoogleApiManager googleApiManager = this.zaa;
+                if (googleApiManager.zao == null || !googleApiManager.zap.contains(this.zad)) {
+                    return false;
+                }
+                this.zaa.zao.zah(connectionResult, this.zah);
+                return true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @WorkerThread
+    public final boolean zaO(boolean z) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        if (!this.zac.isConnected() || !this.zag.isEmpty()) {
+            return false;
+        }
+        if (!this.zae.zag()) {
+            this.zac.disconnect("Timing out service connection.");
+            return true;
+        }
+        if (!z) {
+            return false;
+        }
+        zaJ();
+        return false;
+    }
+
+    public static /* bridge */ /* synthetic */ void zal(zabq zabqVar, zabs zabsVar) {
+        if (zabqVar.zak.contains(zabsVar) && !zabqVar.zaj) {
+            if (zabqVar.zac.isConnected()) {
+                zabqVar.zaG();
+            } else {
+                zabqVar.zao();
+            }
+        }
+    }
+
+    public static /* bridge */ /* synthetic */ void zam(zabq zabqVar, zabs zabsVar) {
+        Feature feature;
+        Feature[] zab;
+        if (zabqVar.zak.remove(zabsVar)) {
+            zabqVar.zaa.zar.removeMessages(15, zabsVar);
+            zabqVar.zaa.zar.removeMessages(16, zabsVar);
+            feature = zabsVar.zab;
+            ArrayList arrayList = new ArrayList(zabqVar.zab.size());
+            for (zai zaiVar : zabqVar.zab) {
+                if ((zaiVar instanceof zac) && (zab = ((zac) zaiVar).zab(zabqVar)) != null && ArrayUtils.contains(zab, feature)) {
+                    arrayList.add(zaiVar);
+                }
+            }
+            int size = arrayList.size();
+            for (int i = 0; i < size; i++) {
+                zai zaiVar2 = (zai) arrayList.get(i);
+                zabqVar.zab.remove(zaiVar2);
+                zaiVar2.zae(new UnsupportedApiCallException(feature));
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnected(@Nullable Bundle bundle) {
+        if (Looper.myLooper() == this.zaa.zar.getLooper()) {
+            zaH();
+        } else {
+            this.zaa.zar.post(new zabm(this));
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.OnConnectionFailedListener
+    @WorkerThread
+    public final void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
+        zar(connectionResult, null);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    public final void onConnectionSuspended(int i) {
+        if (Looper.myLooper() == this.zaa.zar.getLooper()) {
+            zaI(i);
+        } else {
+            this.zaa.zar.post(new zabn(this, i));
+        }
+    }
+
+    public final boolean zaA() {
+        return this.zac.requiresSignIn();
+    }
+
+    @ResultIgnorabilityUnspecified
+    @WorkerThread
+    public final boolean zaB() {
+        return zaO(true);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zau
+    public final void zaa(ConnectionResult connectionResult, Api api, boolean z) {
+        throw null;
+    }
+
+    public final int zab() {
+        return this.zah;
+    }
+
+    @WorkerThread
+    public final int zac() {
+        return this.zam;
+    }
+
+    @Nullable
+    @WorkerThread
+    public final ConnectionResult zad() {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        return this.zal;
+    }
+
+    public final Api.Client zaf() {
+        return this.zac;
+    }
+
+    public final Map zah() {
+        return this.zag;
+    }
+
+    @WorkerThread
+    public final void zan() {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        this.zal = null;
+    }
+
+    @WorkerThread
+    public final void zao() {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        if (this.zac.isConnected() || this.zac.isConnecting()) {
+            return;
+        }
+        try {
+            GoogleApiManager googleApiManager = this.zaa;
+            int zab = googleApiManager.zak.zab(googleApiManager.zai, this.zac);
+            if (zab == 0) {
+                GoogleApiManager googleApiManager2 = this.zaa;
+                Api.Client client = this.zac;
+                zabu zabuVar = new zabu(googleApiManager2, client, this.zad);
+                if (client.requiresSignIn()) {
+                    ((zact) Preconditions.checkNotNull(this.zai)).zae(zabuVar);
+                }
+                try {
+                    this.zac.connect(zabuVar);
+                    return;
+                } catch (SecurityException e) {
+                    zar(new ConnectionResult(10), e);
+                    return;
+                }
+            }
+            ConnectionResult connectionResult = new ConnectionResult(zab, null);
+            Log.w("GoogleApiManager", "The service for " + this.zac.getClass().getName() + " is not available: " + connectionResult.toString());
+            zar(connectionResult, null);
+        } catch (IllegalStateException e2) {
+            zar(new ConnectionResult(10), e2);
+        }
+    }
+
+    @WorkerThread
+    public final void zap(zai zaiVar) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        if (this.zac.isConnected()) {
+            if (zaM(zaiVar)) {
+                zaJ();
+                return;
+            } else {
+                this.zab.add(zaiVar);
+                return;
+            }
+        }
+        this.zab.add(zaiVar);
+        ConnectionResult connectionResult = this.zal;
+        if (connectionResult == null || !connectionResult.hasResolution()) {
+            zao();
+        } else {
+            zar(this.zal, null);
+        }
+    }
+
+    @WorkerThread
+    public final void zaq() {
+        this.zam++;
+    }
+
+    @WorkerThread
+    public final void zar(@NonNull ConnectionResult connectionResult, @Nullable Exception exc) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        zact zactVar = this.zai;
+        if (zactVar != null) {
+            zactVar.zaf();
+        }
+        zan();
+        this.zaa.zak.zac();
+        zaD(connectionResult);
+        if ((this.zac instanceof com.google.android.gms.common.internal.service.zap) && connectionResult.getErrorCode() != 24) {
+            this.zaa.zaf = true;
+            GoogleApiManager googleApiManager = this.zaa;
+            googleApiManager.zar.sendMessageDelayed(googleApiManager.zar.obtainMessage(19), PeriodicWorkRequest.MIN_PERIODIC_FLEX_MILLIS);
+        }
+        if (connectionResult.getErrorCode() == 4) {
+            zaE(GoogleApiManager.zab);
+            return;
+        }
+        if (this.zab.isEmpty()) {
+            this.zal = connectionResult;
+            return;
+        }
+        if (exc != null) {
+            Preconditions.checkHandlerThread(this.zaa.zar);
+            zaF(null, exc, false);
+            return;
+        }
+        if (!this.zaa.zas) {
+            zaE(GoogleApiManager.zaF(this.zad, connectionResult));
+            return;
+        }
+        zaF(GoogleApiManager.zaF(this.zad, connectionResult), null, true);
+        if (this.zab.isEmpty() || zaN(connectionResult) || this.zaa.zaE(connectionResult, this.zah)) {
+            return;
+        }
+        if (connectionResult.getErrorCode() == 18) {
+            this.zaj = true;
+        }
+        if (!this.zaj) {
+            zaE(GoogleApiManager.zaF(this.zad, connectionResult));
+            return;
+        }
+        GoogleApiManager googleApiManager2 = this.zaa;
+        googleApiManager2.zar.sendMessageDelayed(Message.obtain(googleApiManager2.zar, 9, this.zad), 5000L);
+    }
+
+    @WorkerThread
+    public final void zas(@NonNull ConnectionResult connectionResult) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        Api.Client client = this.zac;
+        client.disconnect("onSignInFailed for " + client.getClass().getName() + " with " + String.valueOf(connectionResult));
+        zar(connectionResult, null);
+    }
+
+    @WorkerThread
+    public final void zat(zal zalVar) {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        this.zaf.add(zalVar);
+    }
+
+    @WorkerThread
+    public final void zau() {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        if (this.zaj) {
+            zao();
+        }
+    }
+
+    @WorkerThread
+    public final void zav() {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        zaE(GoogleApiManager.zaa);
+        this.zae.zaf();
+        for (ListenerHolder.ListenerKey listenerKey : (ListenerHolder.ListenerKey[]) this.zag.keySet().toArray(new ListenerHolder.ListenerKey[0])) {
+            zap(new zah(listenerKey, new TaskCompletionSource()));
+        }
+        zaD(new ConnectionResult(4));
+        if (this.zac.isConnected()) {
+            this.zac.onUserSignOut(new zabp(this));
+        }
+    }
+
+    @WorkerThread
+    public final void zaw() {
+        Preconditions.checkHandlerThread(this.zaa.zar);
+        if (this.zaj) {
+            zaL();
+            GoogleApiManager googleApiManager = this.zaa;
+            zaE(googleApiManager.zaj.isGooglePlayServicesAvailable(googleApiManager.zai) == 18 ? new Status(21, "Connection timed out waiting for Google Play services update to complete.") : new Status(22, "API failed to connect while resuming due to an unknown error."));
+            this.zac.disconnect("Timing out connection while resuming.");
+        }
+    }
+
+    public final boolean zaz() {
+        return this.zac.isConnected();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabs.java

@@ -0,0 +1,34 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.internal.Objects;
+
+/* loaded from: classes2.dex */
+final class zabs {
+    private final ApiKey zaa;
+    private final Feature zab;
+
+    public /* synthetic */ zabs(ApiKey apiKey, Feature feature, zabr zabrVar) {
+        this.zaa = apiKey;
+        this.zab = feature;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (obj != null && (obj instanceof zabs)) {
+            zabs zabsVar = (zabs) obj;
+            if (Objects.equal(this.zaa, zabsVar.zaa) && Objects.equal(this.zab, zabsVar.zab)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final int hashCode() {
+        return Objects.hashCode(this.zaa, this.zab);
+    }
+
+    public final String toString() {
+        return Objects.toStringHelper(this).add("key", this.zaa).add("feature", this.zab).toString();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabt.java

@@ -0,0 +1,55 @@
+package com.google.android.gms.common.api.internal;
+
+import android.util.Log;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+final class zabt implements Runnable {
+    final /* synthetic */ ConnectionResult zaa;
+    final /* synthetic */ zabu zab;
+
+    public zabt(zabu zabuVar, ConnectionResult connectionResult) {
+        this.zab = zabuVar;
+        this.zaa = connectionResult;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Map map;
+        ApiKey apiKey;
+        Api.Client client;
+        Api.Client client2;
+        Api.Client client3;
+        Api.Client client4;
+        zabu zabuVar = this.zab;
+        map = zabuVar.zaa.zan;
+        apiKey = zabuVar.zac;
+        zabq zabqVar = (zabq) map.get(apiKey);
+        if (zabqVar == null) {
+            return;
+        }
+        if (!this.zaa.isSuccess()) {
+            zabqVar.zar(this.zaa, null);
+            return;
+        }
+        this.zab.zaf = true;
+        client = this.zab.zab;
+        if (client.requiresSignIn()) {
+            this.zab.zah();
+            return;
+        }
+        try {
+            zabu zabuVar2 = this.zab;
+            client3 = zabuVar2.zab;
+            client4 = zabuVar2.zab;
+            client3.getRemoteService(null, client4.getScopesForConnectionlessNonSignIn());
+        } catch (SecurityException e) {
+            Log.e("GoogleApiManager", "Failed to get service from broker. ", e);
+            client2 = this.zab.zab;
+            client2.disconnect("Failed to get service from broker.");
+            zabqVar.zar(new ConnectionResult(10), null);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabu.java

@@ -0,0 +1,88 @@
+package com.google.android.gms.common.api.internal;
+
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.internal.BaseGmsClient;
+import com.google.android.gms.common.internal.IAccountAccessor;
+import java.util.Map;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+final class zabu implements BaseGmsClient.ConnectionProgressReportCallbacks, zacs {
+    final /* synthetic */ GoogleApiManager zaa;
+    private final Api.Client zab;
+    private final ApiKey zac;
+
+    @Nullable
+    private IAccountAccessor zad = null;
+
+    @Nullable
+    private Set zae = null;
+    private boolean zaf = false;
+
+    public zabu(GoogleApiManager googleApiManager, Api.Client client, ApiKey apiKey) {
+        this.zaa = googleApiManager;
+        this.zab = client;
+        this.zac = apiKey;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    @WorkerThread
+    public final void zah() {
+        IAccountAccessor iAccountAccessor;
+        if (!this.zaf || (iAccountAccessor = this.zad) == null) {
+            return;
+        }
+        this.zab.getRemoteService(iAccountAccessor, this.zae);
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient.ConnectionProgressReportCallbacks
+    public final void onReportServiceBinding(@NonNull ConnectionResult connectionResult) {
+        this.zaa.zar.post(new zabt(this, connectionResult));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zacs
+    @WorkerThread
+    public final void zae(ConnectionResult connectionResult) {
+        Map map;
+        map = this.zaa.zan;
+        zabq zabqVar = (zabq) map.get(this.zac);
+        if (zabqVar != null) {
+            zabqVar.zas(connectionResult);
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zacs
+    @WorkerThread
+    public final void zag(int i) {
+        Map map;
+        boolean z;
+        map = this.zaa.zan;
+        zabq zabqVar = (zabq) map.get(this.zac);
+        if (zabqVar != null) {
+            z = zabqVar.zaj;
+            if (z) {
+                zabqVar.zas(new ConnectionResult(17));
+            } else {
+                zabqVar.onConnectionSuspended(i);
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zacs
+    @WorkerThread
+    public final void zaf(@Nullable IAccountAccessor iAccountAccessor, @Nullable Set set) {
+        if (iAccountAccessor == null || set == null) {
+            Log.wtf("GoogleApiManager", "Received null response from onSignInSuccess", new Exception());
+            zae(new ConnectionResult(4));
+        } else {
+            this.zad = iAccountAccessor;
+            this.zae = set;
+            zah();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabv.java

@@ -0,0 +1,47 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApi;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+
+/* loaded from: classes2.dex */
+public final class zabv extends zaag {
+    private final GoogleApi zaa;
+
+    public zabv(GoogleApi googleApi) {
+        super("Method is not supported by connectionless client. APIs supporting connectionless client must not call this method.");
+        this.zaa = googleApi;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final <A extends Api.AnyClient, R extends Result, T extends BaseImplementation.ApiMethodImpl<R, A>> T enqueue(@NonNull T t) {
+        return (T) this.zaa.doRead((GoogleApi) t);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T execute(@NonNull T t) {
+        return (T) this.zaa.doWrite((GoogleApi) t);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final Context getContext() {
+        return this.zaa.getApplicationContext();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final Looper getLooper() {
+        return this.zaa.getLooper();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void zao(zada zadaVar) {
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void zap(zada zadaVar) {
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabw.java

@@ -0,0 +1,6 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+public abstract class zabw {
+    public abstract void zaa();
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabx.java

@@ -0,0 +1,44 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes2.dex */
+public final class zabx extends BroadcastReceiver {
+
+    @Nullable
+    Context zaa;
+    private final zabw zab;
+
+    public zabx(zabw zabwVar) {
+        this.zab = zabwVar;
+    }
+
+    @Override // android.content.BroadcastReceiver
+    public final void onReceive(Context context, Intent intent) {
+        Uri data = intent.getData();
+        if ("com.google.android.gms".equals(data != null ? data.getSchemeSpecificPart() : null)) {
+            this.zab.zaa();
+            zab();
+        }
+    }
+
+    public final void zaa(Context context) {
+        this.zaa = context;
+    }
+
+    public final synchronized void zab() {
+        try {
+            Context context = this.zaa;
+            if (context != null) {
+                context.unregisterReceiver(this);
+            }
+            this.zaa = null;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaby.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.IBinder;
+import android.os.RemoteException;
+import com.google.android.gms.common.api.Status;
+
+/* loaded from: classes2.dex */
+public final class zaby extends com.google.android.gms.internal.base.zaa implements IStatusCallback {
+    public zaby(IBinder iBinder) {
+        super(iBinder, "com.google.android.gms.common.api.internal.IStatusCallback");
+    }
+
+    @Override // com.google.android.gms.common.api.internal.IStatusCallback
+    public final void onResult(Status status) throws RemoteException {
+        throw null;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zabz.java

@@ -0,0 +1,14 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+
+/* loaded from: classes2.dex */
+public interface zabz {
+    void zaa(ConnectionResult connectionResult);
+
+    void zab(@Nullable Bundle bundle);
+
+    void zac(int i, boolean z);
+}

decompiled/sources/com/google/android/gms/common/api/internal/zac.java

@@ -0,0 +1,16 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.Feature;
+
+/* loaded from: classes2.dex */
+public abstract class zac extends zai {
+    public zac(int i) {
+        super(i);
+    }
+
+    public abstract boolean zaa(zabq zabqVar);
+
+    @Nullable
+    public abstract Feature[] zab(zabq zabqVar);
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaca.java

@@ -0,0 +1,40 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public interface zaca {
+    ConnectionResult zab();
+
+    ConnectionResult zac(long j, TimeUnit timeUnit);
+
+    @Nullable
+    ConnectionResult zad(@NonNull Api api);
+
+    BaseImplementation.ApiMethodImpl zae(@NonNull BaseImplementation.ApiMethodImpl apiMethodImpl);
+
+    BaseImplementation.ApiMethodImpl zaf(@NonNull BaseImplementation.ApiMethodImpl apiMethodImpl);
+
+    void zaq();
+
+    void zar();
+
+    void zas(String str, @Nullable FileDescriptor fileDescriptor, PrintWriter printWriter, @Nullable String[] strArr);
+
+    void zat();
+
+    void zau();
+
+    boolean zaw();
+
+    boolean zax();
+
+    boolean zay(SignInConnectionListener signInConnectionListener);
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacc.java

@@ -0,0 +1,71 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import java.util.concurrent.CancellationException;
+
+/* loaded from: classes2.dex */
+public final class zacc extends zap {
+    private TaskCompletionSource zad;
+
+    private zacc(LifecycleFragment lifecycleFragment) {
+        super(lifecycleFragment, GoogleApiAvailability.getInstance());
+        this.zad = new TaskCompletionSource();
+        this.mLifecycleFragment.addCallback("GmsAvailabilityHelper", this);
+    }
+
+    public static zacc zaa(@NonNull Activity activity) {
+        LifecycleFragment fragment = LifecycleCallback.getFragment(activity);
+        zacc zaccVar = (zacc) fragment.getCallbackOrNull("GmsAvailabilityHelper", zacc.class);
+        if (zaccVar == null) {
+            return new zacc(fragment);
+        }
+        if (zaccVar.zad.getTask().isComplete()) {
+            zaccVar.zad = new TaskCompletionSource();
+        }
+        return zaccVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.LifecycleCallback
+    public final void onDestroy() {
+        super.onDestroy();
+        this.zad.trySetException(new CancellationException("Host activity was destroyed before Google Play services could be made available."));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap
+    public final void zab(ConnectionResult connectionResult, int i) {
+        String errorMessage = connectionResult.getErrorMessage();
+        if (errorMessage == null) {
+            errorMessage = "Error connecting to Google Play services";
+        }
+        this.zad.setException(new ApiException(new Status(connectionResult, errorMessage, connectionResult.getErrorCode())));
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap
+    public final void zac() {
+        Activity lifecycleActivity = this.mLifecycleFragment.getLifecycleActivity();
+        if (lifecycleActivity == null) {
+            this.zad.trySetException(new ApiException(new Status(8)));
+            return;
+        }
+        int isGooglePlayServicesAvailable = this.zac.isGooglePlayServicesAvailable(lifecycleActivity);
+        if (isGooglePlayServicesAvailable == 0) {
+            this.zad.trySetResult(null);
+        } else {
+            if (this.zad.getTask().isComplete()) {
+                return;
+            }
+            zah(new ConnectionResult(isGooglePlayServicesAvailable, null), 0);
+        }
+    }
+
+    public final Task zad() {
+        return this.zad.getTask();
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacd.java

@@ -0,0 +1,159 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.internal.BaseGmsClient;
+import com.google.android.gms.common.internal.ConnectionTelemetryConfiguration;
+import com.google.android.gms.common.internal.MethodInvocation;
+import com.google.android.gms.common.internal.RootTelemetryConfigManager;
+import com.google.android.gms.common.internal.RootTelemetryConfiguration;
+import com.google.android.gms.common.util.ArrayUtils;
+import com.google.android.gms.tasks.OnCompleteListener;
+import com.google.android.gms.tasks.Task;
+
+/* loaded from: classes2.dex */
+final class zacd implements OnCompleteListener {
+    private final GoogleApiManager zaa;
+    private final int zab;
+    private final ApiKey zac;
+    private final long zad;
+    private final long zae;
+
+    @VisibleForTesting
+    public zacd(GoogleApiManager googleApiManager, int i, ApiKey apiKey, long j, long j2, @Nullable String str, @Nullable String str2) {
+        this.zaa = googleApiManager;
+        this.zab = i;
+        this.zac = apiKey;
+        this.zad = j;
+        this.zae = j2;
+    }
+
+    @Nullable
+    public static zacd zaa(GoogleApiManager googleApiManager, int i, ApiKey apiKey) {
+        boolean z;
+        if (!googleApiManager.zaD()) {
+            return null;
+        }
+        RootTelemetryConfiguration config = RootTelemetryConfigManager.getInstance().getConfig();
+        if (config == null) {
+            z = true;
+        } else {
+            if (!config.getMethodInvocationTelemetryEnabled()) {
+                return null;
+            }
+            z = config.getMethodTimingTelemetryEnabled();
+            zabq zai = googleApiManager.zai(apiKey);
+            if (zai != null) {
+                if (!(zai.zaf() instanceof BaseGmsClient)) {
+                    return null;
+                }
+                BaseGmsClient baseGmsClient = (BaseGmsClient) zai.zaf();
+                if (baseGmsClient.hasConnectionInfo() && !baseGmsClient.isConnecting()) {
+                    ConnectionTelemetryConfiguration zab = zab(zai, baseGmsClient, i);
+                    if (zab == null) {
+                        return null;
+                    }
+                    zai.zaq();
+                    z = zab.getMethodTimingTelemetryEnabled();
+                }
+            }
+        }
+        return new zacd(googleApiManager, i, apiKey, z ? System.currentTimeMillis() : 0L, z ? SystemClock.elapsedRealtime() : 0L, null, null);
+    }
+
+    @Nullable
+    private static ConnectionTelemetryConfiguration zab(zabq zabqVar, BaseGmsClient baseGmsClient, int i) {
+        int[] methodInvocationMethodKeyAllowlist;
+        int[] methodInvocationMethodKeyDisallowlist;
+        ConnectionTelemetryConfiguration telemetryConfiguration = baseGmsClient.getTelemetryConfiguration();
+        if (telemetryConfiguration == null || !telemetryConfiguration.getMethodInvocationTelemetryEnabled() || ((methodInvocationMethodKeyAllowlist = telemetryConfiguration.getMethodInvocationMethodKeyAllowlist()) != null ? !ArrayUtils.contains(methodInvocationMethodKeyAllowlist, i) : !((methodInvocationMethodKeyDisallowlist = telemetryConfiguration.getMethodInvocationMethodKeyDisallowlist()) == null || !ArrayUtils.contains(methodInvocationMethodKeyDisallowlist, i))) || zabqVar.zac() >= telemetryConfiguration.getMaxMethodInvocationsLogged()) {
+            return null;
+        }
+        return telemetryConfiguration;
+    }
+
+    @Override // com.google.android.gms.tasks.OnCompleteListener
+    @WorkerThread
+    public final void onComplete(@NonNull Task task) {
+        zabq zai;
+        int i;
+        int i2;
+        int i3;
+        int errorCode;
+        long j;
+        long j2;
+        int i4;
+        if (this.zaa.zaD()) {
+            RootTelemetryConfiguration config = RootTelemetryConfigManager.getInstance().getConfig();
+            if ((config == null || config.getMethodInvocationTelemetryEnabled()) && (zai = this.zaa.zai(this.zac)) != null && (zai.zaf() instanceof BaseGmsClient)) {
+                BaseGmsClient baseGmsClient = (BaseGmsClient) zai.zaf();
+                int i5 = 0;
+                boolean z = this.zad > 0;
+                int gCoreServiceId = baseGmsClient.getGCoreServiceId();
+                int i6 = 100;
+                if (config != null) {
+                    z &= config.getMethodTimingTelemetryEnabled();
+                    int batchPeriodMillis = config.getBatchPeriodMillis();
+                    int maxMethodInvocationsInBatch = config.getMaxMethodInvocationsInBatch();
+                    i = config.getVersion();
+                    if (baseGmsClient.hasConnectionInfo() && !baseGmsClient.isConnecting()) {
+                        ConnectionTelemetryConfiguration zab = zab(zai, baseGmsClient, this.zab);
+                        if (zab == null) {
+                            return;
+                        }
+                        boolean z2 = zab.getMethodTimingTelemetryEnabled() && this.zad > 0;
+                        maxMethodInvocationsInBatch = zab.getMaxMethodInvocationsLogged();
+                        z = z2;
+                    }
+                    i3 = batchPeriodMillis;
+                    i2 = maxMethodInvocationsInBatch;
+                } else {
+                    i = 0;
+                    i2 = 100;
+                    i3 = 5000;
+                }
+                GoogleApiManager googleApiManager = this.zaa;
+                if (task.isSuccessful()) {
+                    errorCode = 0;
+                } else {
+                    if (!task.isCanceled()) {
+                        Exception exception = task.getException();
+                        if (exception instanceof ApiException) {
+                            Status status = ((ApiException) exception).getStatus();
+                            i6 = status.getStatusCode();
+                            ConnectionResult connectionResult = status.getConnectionResult();
+                            if (connectionResult != null) {
+                                errorCode = connectionResult.getErrorCode();
+                                i5 = i6;
+                            }
+                        } else {
+                            i5 = 101;
+                            errorCode = -1;
+                        }
+                    }
+                    i5 = i6;
+                    errorCode = -1;
+                }
+                if (z) {
+                    long j3 = this.zad;
+                    long j4 = this.zae;
+                    long currentTimeMillis = System.currentTimeMillis();
+                    i4 = (int) (SystemClock.elapsedRealtime() - j4);
+                    j2 = currentTimeMillis;
+                    j = j3;
+                } else {
+                    j = 0;
+                    j2 = 0;
+                    i4 = -1;
+                }
+                googleApiManager.zaw(new MethodInvocation(this.zab, i5, errorCode, j, j2, null, null, gCoreServiceId, i4), i, i3, i2);
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zace.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.internal.MethodInvocation;
+
+/* loaded from: classes2.dex */
+final class zace {
+    final MethodInvocation zaa;
+    final int zab;
+    final long zac;
+    final int zad;
+
+    public zace(MethodInvocation methodInvocation, int i, long j, int i2) {
+        this.zaa = methodInvocation;
+        this.zab = i;
+        this.zac = j;
+        this.zad = i2;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zach.java

@@ -0,0 +1,16 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.api.GoogleApi;
+
+/* loaded from: classes2.dex */
+public final class zach {
+    public final zai zaa;
+    public final int zab;
+    public final GoogleApi zac;
+
+    public zach(zai zaiVar, int i, GoogleApi googleApi) {
+        this.zaa = zaiVar;
+        this.zab = i;
+        this.zac = googleApi;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaci.java

@@ -0,0 +1,16 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes2.dex */
+public final class zaci {
+    public final RegisterListenerMethod zaa;
+    public final UnregisterListenerMethod zab;
+    public final Runnable zac;
+
+    public zaci(@NonNull RegisterListenerMethod registerListenerMethod, @NonNull UnregisterListenerMethod unregisterListenerMethod, @NonNull Runnable runnable) {
+        this.zaa = registerListenerMethod;
+        this.zab = unregisterListenerMethod;
+        this.zac = runnable;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacj.java

@@ -0,0 +1,13 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+public final /* synthetic */ class zacj implements Runnable {
+    public static final /* synthetic */ zacj zaa = new zacj();
+
+    private /* synthetic */ zacj() {
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zack.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.RegistrationMethods;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* loaded from: classes2.dex */
+final class zack extends RegisterListenerMethod {
+    final /* synthetic */ RegistrationMethods.Builder zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zack(RegistrationMethods.Builder builder, ListenerHolder listenerHolder, Feature[] featureArr, boolean z, int i) {
+        super(listenerHolder, featureArr, z, i);
+        this.zaa = builder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.RegisterListenerMethod
+    public final void registerListener(Api.AnyClient anyClient, TaskCompletionSource<Void> taskCompletionSource) throws RemoteException {
+        RemoteCall remoteCall;
+        remoteCall = this.zaa.zaa;
+        remoteCall.accept(anyClient, taskCompletionSource);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacl.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.api.internal.RegistrationMethods;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* loaded from: classes2.dex */
+final class zacl extends UnregisterListenerMethod {
+    final /* synthetic */ RegistrationMethods.Builder zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zacl(RegistrationMethods.Builder builder, ListenerHolder.ListenerKey listenerKey) {
+        super(listenerKey);
+        this.zaa = builder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.UnregisterListenerMethod
+    public final void unregisterListener(Api.AnyClient anyClient, TaskCompletionSource<Boolean> taskCompletionSource) throws RemoteException {
+        RemoteCall remoteCall;
+        remoteCall = this.zaa.zab;
+        remoteCall.accept(anyClient, taskCompletionSource);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zaco.java

@@ -0,0 +1,13 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.util.concurrent.NumberedThreadFactory;
+import java.util.concurrent.ExecutorService;
+
+/* loaded from: classes2.dex */
+public final class zaco {
+    private static final ExecutorService zaa = com.google.android.gms.internal.base.zat.zaa().zaa(new NumberedThreadFactory("GAC_Transform"), 1);
+
+    public static ExecutorService zaa() {
+        return zaa;
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacp.java

@@ -0,0 +1,72 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultCallback;
+import com.google.android.gms.common.api.ResultTransform;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.common.api.TransformedResult;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.dex */
+public final class zacp<R extends Result> extends PendingResult<R> {
+    private final Status zaa;
+
+    public zacp(Status status) {
+        Preconditions.checkNotNull(status, "Status must not be null");
+        Preconditions.checkArgument(!status.isSuccess(), "Status must not be success");
+        this.zaa = status;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void addStatusListener(@NonNull PendingResult.StatusListener statusListener) {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final R await() {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void cancel() {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final boolean isCanceled() {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(@NonNull ResultCallback<? super R> resultCallback) {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    @ShowFirstParty
+    public final <S extends Result> TransformedResult<S> then(@NonNull ResultTransform<? super R, ? extends S> resultTransform) {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @NonNull
+    public final Status zaa() {
+        return this.zaa;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @NonNull
+    public final R await(long j, @NonNull TimeUnit timeUnit) {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(@NonNull ResultCallback<? super R> resultCallback, long j, @NonNull TimeUnit timeUnit) {
+        throw new UnsupportedOperationException("Operation not supported on PendingResults generated by ResultTransform.createFailedResult()");
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacq.java

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.ConnectionResult;
+
+/* loaded from: classes2.dex */
+final class zacq implements Runnable {
+    final /* synthetic */ zact zaa;
+
+    public zacq(zact zactVar) {
+        this.zaa = zactVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        zacs zacsVar;
+        zacsVar = this.zaa.zah;
+        zacsVar.zae(new ConnectionResult(4));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacr.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api.internal;
+
+/* loaded from: classes2.dex */
+final class zacr implements Runnable {
+    final /* synthetic */ com.google.android.gms.signin.internal.zak zaa;
+    final /* synthetic */ zact zab;
+
+    public zacr(zact zactVar, com.google.android.gms.signin.internal.zak zakVar) {
+        this.zab = zactVar;
+        this.zaa = zakVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        zact.zad(this.zab, this.zaa);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacs.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.internal.IAccountAccessor;
+import java.util.Set;
+
+@WorkerThread
+/* loaded from: classes2.dex */
+public interface zacs {
+    void zae(ConnectionResult connectionResult);
+
+    void zaf(@Nullable IAccountAccessor iAccountAccessor, @Nullable Set set);
+
+    void zag(int i);
+}

decompiled/sources/com/google/android/gms/common/api/internal/zact.java

@@ -0,0 +1,110 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Handler;
+import android.util.Log;
+import androidx.annotation.BinderThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class zact extends com.google.android.gms.signin.internal.zac implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
+    private static final Api.AbstractClientBuilder zaa = com.google.android.gms.signin.zad.zac;
+    private final Context zab;
+    private final Handler zac;
+    private final Api.AbstractClientBuilder zad;
+    private final Set zae;
+    private final ClientSettings zaf;
+    private com.google.android.gms.signin.zae zag;
+    private zacs zah;
+
+    @WorkerThread
+    public zact(Context context, Handler handler, @NonNull ClientSettings clientSettings) {
+        Api.AbstractClientBuilder abstractClientBuilder = zaa;
+        this.zab = context;
+        this.zac = handler;
+        this.zaf = (ClientSettings) Preconditions.checkNotNull(clientSettings, "ClientSettings must not be null");
+        this.zae = clientSettings.getRequiredScopes();
+        this.zad = abstractClientBuilder;
+    }
+
+    public static /* bridge */ /* synthetic */ void zad(zact zactVar, com.google.android.gms.signin.internal.zak zakVar) {
+        ConnectionResult zaa2 = zakVar.zaa();
+        if (zaa2.isSuccess()) {
+            com.google.android.gms.common.internal.zav zavVar = (com.google.android.gms.common.internal.zav) Preconditions.checkNotNull(zakVar.zab());
+            ConnectionResult zaa3 = zavVar.zaa();
+            if (!zaa3.isSuccess()) {
+                String valueOf = String.valueOf(zaa3);
+                Log.wtf("SignInCoordinator", "Sign-in succeeded with resolve account failure: ".concat(valueOf), new Exception());
+                zactVar.zah.zae(zaa3);
+                zactVar.zag.disconnect();
+                return;
+            }
+            zactVar.zah.zaf(zavVar.zab(), zactVar.zae);
+        } else {
+            zactVar.zah.zae(zaa2);
+        }
+        zactVar.zag.disconnect();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    @WorkerThread
+    public final void onConnected(@Nullable Bundle bundle) {
+        this.zag.zad(this);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.OnConnectionFailedListener
+    @WorkerThread
+    public final void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
+        this.zah.zae(connectionResult);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ConnectionCallbacks
+    @WorkerThread
+    public final void onConnectionSuspended(int i) {
+        this.zah.zag(i);
+    }
+
+    @Override // com.google.android.gms.signin.internal.zac, com.google.android.gms.signin.internal.zae
+    @BinderThread
+    public final void zab(com.google.android.gms.signin.internal.zak zakVar) {
+        this.zac.post(new zacr(this, zakVar));
+    }
+
+    /* JADX WARN: Type inference failed for: r0v3, types: [com.google.android.gms.common.api.Api$Client, com.google.android.gms.signin.zae] */
+    @WorkerThread
+    public final void zae(zacs zacsVar) {
+        com.google.android.gms.signin.zae zaeVar = this.zag;
+        if (zaeVar != null) {
+            zaeVar.disconnect();
+        }
+        this.zaf.zae(Integer.valueOf(System.identityHashCode(this)));
+        Api.AbstractClientBuilder abstractClientBuilder = this.zad;
+        Context context = this.zab;
+        Handler handler = this.zac;
+        ClientSettings clientSettings = this.zaf;
+        this.zag = abstractClientBuilder.buildClient(context, handler.getLooper(), clientSettings, (ClientSettings) clientSettings.zaa(), (GoogleApiClient.ConnectionCallbacks) this, (GoogleApiClient.OnConnectionFailedListener) this);
+        this.zah = zacsVar;
+        Set set = this.zae;
+        if (set == null || set.isEmpty()) {
+            this.zac.post(new zacq(this));
+        } else {
+            this.zag.zab();
+        }
+    }
+
+    public final void zaf() {
+        com.google.android.gms.signin.zae zaeVar = this.zag;
+        if (zaeVar != null) {
+            zaeVar.disconnect();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacv.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.TaskApiCall;
+import com.google.android.gms.tasks.TaskCompletionSource;
+
+/* loaded from: classes2.dex */
+final class zacv extends TaskApiCall {
+    final /* synthetic */ TaskApiCall.Builder zaa;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public zacv(TaskApiCall.Builder builder, Feature[] featureArr, boolean z, int i) {
+        super(featureArr, z, i);
+        this.zaa = builder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.TaskApiCall
+    public final void doExecute(Api.AnyClient anyClient, TaskCompletionSource taskCompletionSource) throws RemoteException {
+        RemoteCall remoteCall;
+        remoteCall = this.zaa.zaa;
+        remoteCall.accept(anyClient, taskCompletionSource);
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacx.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.ApiException;
+import com.google.android.gms.common.api.Status;
+import com.google.android.gms.tasks.Continuation;
+import com.google.android.gms.tasks.Task;
+
+/* loaded from: classes2.dex */
+final class zacx implements Continuation {
+    @Override // com.google.android.gms.tasks.Continuation
+    public final /* bridge */ /* synthetic */ Object then(@NonNull Task task) throws Exception {
+        if (((Boolean) task.getResult()).booleanValue()) {
+            return null;
+        }
+        throw new ApiException(new Status(13, "listener already unregistered"));
+    }
+}

decompiled/sources/com/google/android/gms/common/api/internal/zacy.java

@@ -0,0 +1,78 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.annotation.WorkerThread;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.PendingResult;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.ResultTransform;
+import com.google.android.gms.common.internal.Preconditions;
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes2.dex */
+final class zacy implements Runnable {
+    final /* synthetic */ Result zaa;
+    final /* synthetic */ zada zab;
+
+    public zacy(zada zadaVar, Result result) {
+        this.zab = zadaVar;
+        this.zaa = result;
+    }
+
+    @Override // java.lang.Runnable
+    @WorkerThread
+    public final void run() {
+        WeakReference weakReference;
+        zacz zaczVar;
+        zacz zaczVar2;
+        WeakReference weakReference2;
+        GoogleApiClient googleApiClient;
+        ResultTransform resultTransform;
+        zacz zaczVar3;
+        zacz zaczVar4;
+        WeakReference weakReference3;
+        try {
+            try {
+                ThreadLocal threadLocal = BasePendingResult.zaa;
+                threadLocal.set(Boolean.TRUE);
+                resultTransform = this.zab.zaa;
+                PendingResult onSuccess = ((ResultTransform) Preconditions.checkNotNull(resultTransform)).onSuccess(this.zaa);
+                zada zadaVar = this.zab;
+                zaczVar3 = zadaVar.zah;
+                zaczVar4 = zadaVar.zah;
+                zaczVar3.sendMessage(zaczVar4.obtainMessage(0, onSuccess));
+                threadLocal.set(Boolean.FALSE);
+                zada zadaVar2 = this.zab;
+                zada.zan(this.zaa);
+                weakReference3 = this.zab.zag;
+                googleApiClient = (GoogleApiClient) weakReference3.get();
+                if (googleApiClient == null) {
+                    return;
+                }
+            } catch (RuntimeException e) {
+                zada zadaVar3 = this.zab;
+                zaczVar = zadaVar3.zah;
+                zaczVar2 = zadaVar3.zah;
+                zaczVar.sendMessage(zaczVar2.obtainMessage(1, e));
+                BasePendingResult.zaa.set(Boolean.FALSE);
+                zada zadaVar4 = this.zab;
+                zada.zan(this.zaa);
+                weakReference2 = this.zab.zag;
+                googleApiClient = (GoogleApiClient) weakReference2.get();
+                if (googleApiClient == null) {
+                    return;
+                }
+            }
+            googleApiClient.zap(this.zab);
+        } catch (Throwable th) {
+            BasePendingResult.zaa.set(Boolean.FALSE);
+            zada zadaVar5 = this.zab;
+            zada.zan(this.zaa);
+            weakReference = this.zab.zag;
+            GoogleApiClient googleApiClient2 = (GoogleApiClient) weakReference.get();
+            if (googleApiClient2 != null) {
+                googleApiClient2.zap(this.zab);
+            }
+            throw th;
+        }
+    }
+}