Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/com/google/android/gms/common/api/Api.java

@@ -0,0 +1,213 @@
+package com.google.android.gms.common.api;
+
+import android.accounts.Account;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.Looper;
+import com.google.android.gms.auth.api.signin.GoogleSignInAccount;
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api.ApiOptions;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.api.internal.ConnectionCallbacks;
+import com.google.android.gms.common.api.internal.OnConnectionFailedListener;
+import com.google.android.gms.common.internal.BaseGmsClient;
+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 com.google.android.gms.common.util.VisibleForTesting;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+/* loaded from: classes3.dex */
+public final class Api<O extends ApiOptions> {
+    private final AbstractClientBuilder zaa;
+    private final ClientKey zab;
+    private final String zac;
+
+    @VisibleForTesting
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public static abstract class AbstractClientBuilder<T extends Client, O> extends BaseClientBuilder<T, O> {
+        @KeepForSdk
+        @Deprecated
+        public T buildClient(Context context, Looper looper, ClientSettings clientSettings, O o4, GoogleApiClient.ConnectionCallbacks connectionCallbacks, GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+            return buildClient(context, looper, clientSettings, (ClientSettings) o4, (ConnectionCallbacks) connectionCallbacks, (OnConnectionFailedListener) onConnectionFailedListener);
+        }
+
+        @KeepForSdk
+        public T buildClient(Context context, Looper looper, ClientSettings clientSettings, O o4, ConnectionCallbacks connectionCallbacks, OnConnectionFailedListener onConnectionFailedListener) {
+            throw new UnsupportedOperationException("buildClient must be implemented");
+        }
+    }
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public interface AnyClient {
+    }
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public static class AnyClientKey<C extends AnyClient> {
+    }
+
+    /* loaded from: classes3.dex */
+    public interface ApiOptions {
+        public static final NoOptions NO_OPTIONS = new NoOptions(null);
+
+        /* loaded from: classes3.dex */
+        public interface HasAccountOptions extends HasOptions, NotRequiredOptions {
+            Account getAccount();
+        }
+
+        /* loaded from: classes3.dex */
+        public interface HasGoogleSignInAccountOptions extends HasOptions {
+            GoogleSignInAccount getGoogleSignInAccount();
+        }
+
+        /* loaded from: classes3.dex */
+        public interface HasOptions extends ApiOptions {
+        }
+
+        /* loaded from: classes3.dex */
+        public static final class NoOptions implements NotRequiredOptions {
+            private NoOptions() {
+            }
+
+            public /* synthetic */ NoOptions(zaa zaaVar) {
+            }
+        }
+
+        /* loaded from: classes3.dex */
+        public interface NotRequiredOptions extends ApiOptions {
+        }
+
+        /* loaded from: classes3.dex */
+        public interface Optional extends HasOptions, NotRequiredOptions {
+        }
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public static abstract class BaseClientBuilder<T extends AnyClient, O> {
+
+        @KeepForSdk
+        public static final int API_PRIORITY_GAMES = 1;
+
+        @KeepForSdk
+        public static final int API_PRIORITY_OTHER = Integer.MAX_VALUE;
+
+        @KeepForSdk
+        public static final int API_PRIORITY_PLUS = 2;
+
+        @KeepForSdk
+        public List<Scope> getImpliedScopes(O o4) {
+            return Collections.EMPTY_LIST;
+        }
+
+        @KeepForSdk
+        public int getPriority() {
+            return Integer.MAX_VALUE;
+        }
+    }
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public interface Client extends AnyClient {
+        @KeepForSdk
+        void connect(BaseGmsClient.ConnectionProgressReportCallbacks connectionProgressReportCallbacks);
+
+        @KeepForSdk
+        void disconnect();
+
+        @KeepForSdk
+        void disconnect(String str);
+
+        @KeepForSdk
+        void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr);
+
+        @KeepForSdk
+        Feature[] getAvailableFeatures();
+
+        @KeepForSdk
+        String getEndpointPackageName();
+
+        @KeepForSdk
+        String getLastDisconnectMessage();
+
+        @KeepForSdk
+        int getMinApkVersion();
+
+        @KeepForSdk
+        void getRemoteService(IAccountAccessor iAccountAccessor, Set<Scope> set);
+
+        @KeepForSdk
+        Feature[] getRequiredFeatures();
+
+        @KeepForSdk
+        Set<Scope> getScopesForConnectionlessNonSignIn();
+
+        @KeepForSdk
+        IBinder getServiceBrokerBinder();
+
+        @KeepForSdk
+        Intent getSignInIntent();
+
+        @KeepForSdk
+        boolean isConnected();
+
+        @KeepForSdk
+        boolean isConnecting();
+
+        @KeepForSdk
+        void onUserSignOut(BaseGmsClient.SignOutCallbacks signOutCallbacks);
+
+        @KeepForSdk
+        boolean providesSignIn();
+
+        @KeepForSdk
+        boolean requiresAccount();
+
+        @KeepForSdk
+        boolean requiresGooglePlayServices();
+
+        @KeepForSdk
+        boolean requiresSignIn();
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public static final class ClientKey<C extends Client> extends AnyClientKey<C> {
+    }
+
+    @KeepForSdk
+    public <C extends Client> Api(String str, AbstractClientBuilder<C, O> abstractClientBuilder, ClientKey<C> clientKey) {
+        Preconditions.checkNotNull(abstractClientBuilder, "Cannot construct an Api with a null ClientBuilder");
+        Preconditions.checkNotNull(clientKey, "Cannot construct an Api with a null ClientKey");
+        this.zac = str;
+        this.zaa = abstractClientBuilder;
+        this.zab = clientKey;
+    }
+
+    public final AbstractClientBuilder zaa() {
+        return this.zaa;
+    }
+
+    public final AnyClientKey zab() {
+        return this.zab;
+    }
+
+    public final BaseClientBuilder zac() {
+        return this.zaa;
+    }
+
+    public final String zad() {
+        return this.zac;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/ApiException.java

@@ -0,0 +1,26 @@
+package com.google.android.gms.common.api;
+
+/* loaded from: classes3.dex */
+public class ApiException extends Exception {
+
+    @Deprecated
+    protected final Status mStatus;
+
+    public ApiException(Status status) {
+        super(status.getStatusCode() + ": " + (status.getStatusMessage() != null ? status.getStatusMessage() : ""));
+        this.mStatus = status;
+    }
+
+    public Status getStatus() {
+        return this.mStatus;
+    }
+
+    public int getStatusCode() {
+        return this.mStatus.getStatusCode();
+    }
+
+    @Deprecated
+    public String getStatusMessage() {
+        return this.mStatus.getStatusMessage();
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/AvailabilityException.java

@@ -0,0 +1,60 @@
+package com.google.android.gms.common.api;
+
+import android.text.TextUtils;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.internal.ApiKey;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.ArrayList;
+import java.util.Iterator;
+import s.C0581a;
+import s.b;
+import s.e;
+
+/* loaded from: classes3.dex */
+public class AvailabilityException extends Exception {
+    private final e zaa;
+
+    public AvailabilityException(e eVar) {
+        this.zaa = eVar;
+    }
+
+    public ConnectionResult getConnectionResult(GoogleApi<? extends Api.ApiOptions> googleApi) {
+        ApiKey<? extends Api.ApiOptions> apiKey = googleApi.getApiKey();
+        boolean z3 = this.zaa.get(apiKey) != null;
+        Preconditions.checkArgument(z3, "The given API (" + apiKey.zaa() + ") was not part of the availability request.");
+        return (ConnectionResult) Preconditions.checkNotNull((ConnectionResult) this.zaa.get(apiKey));
+    }
+
+    @Override // java.lang.Throwable
+    public String getMessage() {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = ((b) this.zaa.keySet()).iterator();
+        boolean z3 = true;
+        while (true) {
+            C0581a c0581a = (C0581a) it;
+            if (!c0581a.hasNext()) {
+                break;
+            }
+            ApiKey apiKey = (ApiKey) c0581a.next();
+            ConnectionResult connectionResult = (ConnectionResult) Preconditions.checkNotNull((ConnectionResult) this.zaa.get(apiKey));
+            z3 &= !connectionResult.isSuccess();
+            arrayList.add(apiKey.zaa() + ": " + String.valueOf(connectionResult));
+        }
+        StringBuilder sb = new StringBuilder();
+        if (z3) {
+            sb.append("None of the queried APIs are available. ");
+        } else {
+            sb.append("Some of the queried APIs are unavailable. ");
+        }
+        sb.append(TextUtils.join("; ", arrayList));
+        return sb.toString();
+    }
+
+    public ConnectionResult getConnectionResult(HasApiKey<? extends Api.ApiOptions> hasApiKey) {
+        ApiKey<? extends Api.ApiOptions> apiKey = hasApiKey.getApiKey();
+        boolean z3 = this.zaa.get(apiKey) != null;
+        Preconditions.checkArgument(z3, "The given API (" + apiKey.zaa() + ") was not part of the availability request.");
+        return (ConnectionResult) Preconditions.checkNotNull((ConnectionResult) this.zaa.get(apiKey));
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/Batch.java

@@ -0,0 +1,66 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.internal.BasePendingResult;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class Batch extends BasePendingResult<BatchResult> {
+    private int zae;
+    private boolean zaf;
+    private boolean zag;
+    private final PendingResult[] zah;
+    private final Object zai;
+
+    /* loaded from: classes3.dex */
+    public static final class Builder {
+        private List zaa = new ArrayList();
+        private GoogleApiClient zab;
+
+        public Builder(GoogleApiClient googleApiClient) {
+            this.zab = googleApiClient;
+        }
+
+        public <R extends Result> BatchResultToken<R> add(PendingResult<R> pendingResult) {
+            BatchResultToken<R> batchResultToken = new BatchResultToken<>(this.zaa.size());
+            this.zaa.add(pendingResult);
+            return batchResultToken;
+        }
+
+        public Batch build() {
+            return new Batch(this.zaa, this.zab, null);
+        }
+    }
+
+    public /* synthetic */ Batch(List list, GoogleApiClient googleApiClient, zac zacVar) {
+        super(googleApiClient);
+        this.zai = new Object();
+        int size = list.size();
+        this.zae = size;
+        PendingResult[] pendingResultArr = new PendingResult[size];
+        this.zah = pendingResultArr;
+        if (list.isEmpty()) {
+            setResult(new BatchResult(Status.RESULT_SUCCESS, pendingResultArr));
+            return;
+        }
+        for (int i = 0; i < list.size(); i++) {
+            PendingResult pendingResult = (PendingResult) list.get(i);
+            this.zah[i] = pendingResult;
+            pendingResult.addStatusListener(new zab(this));
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.internal.BasePendingResult, com.google.android.gms.common.api.PendingResult
+    public void cancel() {
+        super.cancel();
+        for (PendingResult pendingResult : this.zah) {
+            pendingResult.cancel();
+        }
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.google.android.gms.common.api.internal.BasePendingResult
+    public BatchResult createFailedResult(Status status) {
+        return new BatchResult(status, this.zah);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/BatchResult.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public final class BatchResult implements Result {
+    private final Status zaa;
+    private final PendingResult[] zab;
+
+    public BatchResult(Status status, PendingResult[] pendingResultArr) {
+        this.zaa = status;
+        this.zab = pendingResultArr;
+    }
+
+    @Override // com.google.android.gms.common.api.Result
+    public Status getStatus() {
+        return this.zaa;
+    }
+
+    public <R extends Result> R take(BatchResultToken<R> batchResultToken) {
+        Preconditions.checkArgument(batchResultToken.mId < this.zab.length, "The result token does not belong to this batch");
+        return (R) this.zab[batchResultToken.mId].await(0L, TimeUnit.MILLISECONDS);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/BatchResultToken.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.Result;
+
+/* loaded from: classes3.dex */
+public final class BatchResultToken<R extends Result> {
+    protected final int mId;
+
+    public BatchResultToken(int i) {
+        this.mId = i;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/BooleanResult.java

@@ -0,0 +1,45 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+/* loaded from: classes3.dex */
+public class BooleanResult implements Result {
+    private final Status zaa;
+    private final boolean zab;
+
+    @ShowFirstParty
+    @KeepForSdk
+    public BooleanResult(Status status, boolean z3) {
+        this.zaa = (Status) Preconditions.checkNotNull(status, "Status must not be null");
+        this.zab = z3;
+    }
+
+    public final boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof BooleanResult)) {
+            return false;
+        }
+        BooleanResult booleanResult = (BooleanResult) obj;
+        return this.zaa.equals(booleanResult.zaa) && this.zab == booleanResult.zab;
+    }
+
+    @Override // com.google.android.gms.common.api.Result
+    public Status getStatus() {
+        return this.zaa;
+    }
+
+    public boolean getValue() {
+        return this.zab;
+    }
+
+    public final int hashCode() {
+        return ((this.zaa.hashCode() + 527) * 31) + (this.zab ? 1 : 0);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/CommonStatusCodes.java

@@ -0,0 +1,86 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.measurement.internal.a;
+
+/* loaded from: classes3.dex */
+public class CommonStatusCodes {
+    public static final int API_NOT_CONNECTED = 17;
+    public static final int CANCELED = 16;
+    public static final int CONNECTION_SUSPENDED_DURING_CALL = 20;
+    public static final int DEVELOPER_ERROR = 10;
+    public static final int ERROR = 13;
+    public static final int INTERNAL_ERROR = 8;
+    public static final int INTERRUPTED = 14;
+    public static final int INVALID_ACCOUNT = 5;
+    public static final int NETWORK_ERROR = 7;
+    public static final int RECONNECTION_TIMED_OUT = 22;
+    public static final int RECONNECTION_TIMED_OUT_DURING_UPDATE = 21;
+    public static final int REMOTE_EXCEPTION = 19;
+    public static final int RESOLUTION_REQUIRED = 6;
+
+    @Deprecated
+    public static final int SERVICE_DISABLED = 3;
+
+    @Deprecated
+    public static final int SERVICE_VERSION_UPDATE_REQUIRED = 2;
+    public static final int SIGN_IN_REQUIRED = 4;
+    public static final int SUCCESS = 0;
+    public static final int SUCCESS_CACHE = -1;
+    public static final int TIMEOUT = 15;
+
+    @KeepForSdk
+    public CommonStatusCodes() {
+    }
+
+    public static String getStatusCodeString(int i) {
+        switch (i) {
+            case -1:
+                return "SUCCESS_CACHE";
+            case 0:
+                return "SUCCESS";
+            case 1:
+            case 9:
+            case 11:
+            case 12:
+            default:
+                return a.l(i, "unknown status code: ");
+            case 2:
+                return "SERVICE_VERSION_UPDATE_REQUIRED";
+            case 3:
+                return "SERVICE_DISABLED";
+            case 4:
+                return "SIGN_IN_REQUIRED";
+            case 5:
+                return "INVALID_ACCOUNT";
+            case 6:
+                return "RESOLUTION_REQUIRED";
+            case 7:
+                return "NETWORK_ERROR";
+            case 8:
+                return "INTERNAL_ERROR";
+            case 10:
+                return "DEVELOPER_ERROR";
+            case 13:
+                return "ERROR";
+            case 14:
+                return "INTERRUPTED";
+            case 15:
+                return "TIMEOUT";
+            case 16:
+                return "CANCELED";
+            case 17:
+                return "API_NOT_CONNECTED";
+            case 18:
+                return "DEAD_CLIENT";
+            case 19:
+                return "REMOTE_EXCEPTION";
+            case 20:
+                return "CONNECTION_SUSPENDED_DURING_CALL";
+            case 21:
+                return "RECONNECTION_TIMED_OUT_DURING_UPDATE";
+            case 22:
+                return "RECONNECTION_TIMED_OUT";
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/DataBufferResponse.java

@@ -0,0 +1,71 @@
+package com.google.android.gms.common.api;
+
+import android.os.Bundle;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.data.AbstractDataBuffer;
+import com.google.android.gms.common.data.DataBuffer;
+import java.util.Iterator;
+
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class DataBufferResponse<T, R extends AbstractDataBuffer<T> & Result> extends Response<R> implements DataBuffer<T> {
+    @KeepForSdk
+    public DataBufferResponse() {
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer, java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+        ((AbstractDataBuffer) getResult()).close();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer
+    public final T get(int i) {
+        return (T) ((AbstractDataBuffer) getResult()).get(i);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer
+    public final int getCount() {
+        return ((AbstractDataBuffer) getResult()).getCount();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer
+    public final Bundle getMetadata() {
+        return ((AbstractDataBuffer) getResult()).getMetadata();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer
+    public final boolean isClosed() {
+        return ((AbstractDataBuffer) getResult()).isClosed();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer, java.lang.Iterable
+    public final Iterator<T> iterator() {
+        return ((AbstractDataBuffer) getResult()).iterator();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer, com.google.android.gms.common.api.Releasable
+    public final void release() {
+        ((AbstractDataBuffer) getResult()).release();
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Override // com.google.android.gms.common.data.DataBuffer
+    public final Iterator<T> singleRefIterator() {
+        return ((AbstractDataBuffer) getResult()).singleRefIterator();
+    }
+
+    /* JADX WARN: Incorrect types in method signature: (TR;)V */
+    /* JADX WARN: Multi-variable type inference failed */
+    @KeepForSdk
+    public DataBufferResponse(AbstractDataBuffer abstractDataBuffer) {
+        super(abstractDataBuffer);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/GoogleApi.java

@@ -0,0 +1,383 @@
+package com.google.android.gms.common.api;
+
+import android.accounts.Account;
+import android.app.Activity;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import com.google.android.gms.auth.api.signin.GoogleSignInAccount;
+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.api.GoogleApiClient;
+import com.google.android.gms.common.api.internal.ApiExceptionMapper;
+import com.google.android.gms.common.api.internal.ApiKey;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.api.internal.GoogleApiManager;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.api.internal.ListenerHolders;
+import com.google.android.gms.common.api.internal.NonGmsServiceBrokerClient;
+import com.google.android.gms.common.api.internal.RegisterListenerMethod;
+import com.google.android.gms.common.api.internal.RegistrationMethods;
+import com.google.android.gms.common.api.internal.StatusExceptionMapper;
+import com.google.android.gms.common.api.internal.TaskApiCall;
+import com.google.android.gms.common.api.internal.UnregisterListenerMethod;
+import com.google.android.gms.common.api.internal.zaae;
+import com.google.android.gms.common.api.internal.zabq;
+import com.google.android.gms.common.api.internal.zabv;
+import com.google.android.gms.common.api.internal.zact;
+import com.google.android.gms.common.internal.BaseGmsClient;
+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 com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collections;
+import java.util.Set;
+import org.checkerframework.checker.initialization.qual.NotOnlyInitialized;
+
+/* loaded from: classes3.dex */
+public abstract class GoogleApi<O extends Api.ApiOptions> implements HasApiKey<O> {
+    protected final GoogleApiManager zaa;
+    private final Context zab;
+    private final String zac;
+    private final Api zad;
+    private final Api.ApiOptions zae;
+    private final ApiKey zaf;
+    private final Looper zag;
+    private final int zah;
+
+    @NotOnlyInitialized
+    private final GoogleApiClient zai;
+    private final StatusExceptionMapper zaj;
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public static class Settings {
+
+        @KeepForSdk
+        public static final Settings DEFAULT_SETTINGS = new Builder().build();
+        public final StatusExceptionMapper zaa;
+        public final Looper zab;
+
+        @KeepForSdk
+        /* loaded from: classes3.dex */
+        public static class Builder {
+            private StatusExceptionMapper zaa;
+            private Looper zab;
+
+            @KeepForSdk
+            public Builder() {
+            }
+
+            /* JADX WARN: Multi-variable type inference failed */
+            @KeepForSdk
+            public Settings build() {
+                if (this.zaa == null) {
+                    this.zaa = new ApiExceptionMapper();
+                }
+                if (this.zab == null) {
+                    this.zab = Looper.getMainLooper();
+                }
+                return new Settings(this.zaa, this.zab);
+            }
+
+            @KeepForSdk
+            public Builder setLooper(Looper looper) {
+                Preconditions.checkNotNull(looper, "Looper must not be null.");
+                this.zab = looper;
+                return this;
+            }
+
+            @KeepForSdk
+            public Builder setMapper(StatusExceptionMapper statusExceptionMapper) {
+                Preconditions.checkNotNull(statusExceptionMapper, "StatusExceptionMapper must not be null.");
+                this.zaa = statusExceptionMapper;
+                return this;
+            }
+        }
+
+        @KeepForSdk
+        private Settings(StatusExceptionMapper statusExceptionMapper, Account account, Looper looper) {
+            this.zaa = statusExceptionMapper;
+            this.zab = looper;
+        }
+    }
+
+    @KeepForSdk
+    public GoogleApi(Activity activity, Api<O> api, O o4, Settings settings) {
+        this(activity, activity, api, o4, settings);
+    }
+
+    private final BaseImplementation.ApiMethodImpl zad(int i, BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        apiMethodImpl.zak();
+        this.zaa.zaw(this, i, apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    private final Task zae(int i, TaskApiCall taskApiCall) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        this.zaa.zax(this, i, taskApiCall, taskCompletionSource, this.zaj);
+        return taskCompletionSource.getTask();
+    }
+
+    @KeepForSdk
+    public GoogleApiClient asGoogleApiClient() {
+        return this.zai;
+    }
+
+    @KeepForSdk
+    public ClientSettings.Builder createClientSettingsBuilder() {
+        Account account;
+        Set<Scope> set;
+        GoogleSignInAccount googleSignInAccount;
+        ClientSettings.Builder builder = new ClientSettings.Builder();
+        Api.ApiOptions apiOptions = this.zae;
+        if (!(apiOptions instanceof Api.ApiOptions.HasGoogleSignInAccountOptions) || (googleSignInAccount = ((Api.ApiOptions.HasGoogleSignInAccountOptions) apiOptions).getGoogleSignInAccount()) == null) {
+            Api.ApiOptions apiOptions2 = this.zae;
+            account = apiOptions2 instanceof Api.ApiOptions.HasAccountOptions ? ((Api.ApiOptions.HasAccountOptions) apiOptions2).getAccount() : null;
+        } else {
+            account = googleSignInAccount.getAccount();
+        }
+        builder.zab(account);
+        Api.ApiOptions apiOptions3 = this.zae;
+        if (apiOptions3 instanceof Api.ApiOptions.HasGoogleSignInAccountOptions) {
+            GoogleSignInAccount googleSignInAccount2 = ((Api.ApiOptions.HasGoogleSignInAccountOptions) apiOptions3).getGoogleSignInAccount();
+            set = googleSignInAccount2 == null ? Collections.EMPTY_SET : googleSignInAccount2.getRequestedScopes();
+        } else {
+            set = Collections.EMPTY_SET;
+        }
+        builder.zaa(set);
+        builder.zac(this.zab.getClass().getName());
+        builder.setRealClientPackageName(this.zab.getPackageName());
+        return builder;
+    }
+
+    @KeepForSdk
+    public Task<Boolean> disconnectService() {
+        return this.zaa.zap(this);
+    }
+
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T doBestEffortWrite(T t2) {
+        zad(2, t2);
+        return t2;
+    }
+
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T doRead(T t2) {
+        zad(0, t2);
+        return t2;
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public <A extends Api.AnyClient, T extends RegisterListenerMethod<A, ?>, U extends UnregisterListenerMethod<A, ?>> Task<Void> doRegisterEventListener(T t2, U u3) {
+        Preconditions.checkNotNull(t2);
+        Preconditions.checkNotNull(u3);
+        Preconditions.checkNotNull(t2.getListenerKey(), "Listener has already been released.");
+        Preconditions.checkNotNull(u3.getListenerKey(), "Listener has already been released.");
+        Preconditions.checkArgument(Objects.equal(t2.getListenerKey(), u3.getListenerKey()), "Listener registration and unregistration methods must be constructed with the same ListenerHolder.");
+        return this.zaa.zaq(this, t2, u3, new Runnable() { // from class: com.google.android.gms.common.api.zad
+            @Override // java.lang.Runnable
+            public final void run() {
+            }
+        });
+    }
+
+    @KeepForSdk
+    public Task<Boolean> doUnregisterEventListener(ListenerHolder.ListenerKey<?> listenerKey) {
+        return doUnregisterEventListener(listenerKey, 0);
+    }
+
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T doWrite(T t2) {
+        zad(1, t2);
+        return t2;
+    }
+
+    @Override // com.google.android.gms.common.api.HasApiKey
+    public final ApiKey<O> getApiKey() {
+        return this.zaf;
+    }
+
+    @KeepForSdk
+    public O getApiOptions() {
+        return (O) this.zae;
+    }
+
+    @KeepForSdk
+    public Context getApplicationContext() {
+        return this.zab;
+    }
+
+    @KeepForSdk
+    public String getContextAttributionTag() {
+        return this.zac;
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public String getContextFeatureId() {
+        return this.zac;
+    }
+
+    @KeepForSdk
+    public Looper getLooper() {
+        return this.zag;
+    }
+
+    @KeepForSdk
+    public <L> ListenerHolder<L> registerListener(L l4, String str) {
+        return ListenerHolders.createListenerHolder(l4, this.zag, str);
+    }
+
+    public final int zaa() {
+        return this.zah;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public final Api.Client zab(Looper looper, zabq zabqVar) {
+        Api.Client buildClient = ((Api.AbstractClientBuilder) Preconditions.checkNotNull(this.zad.zaa())).buildClient(this.zab, looper, createClientSettingsBuilder().build(), (ClientSettings) this.zae, (GoogleApiClient.ConnectionCallbacks) zabqVar, (GoogleApiClient.OnConnectionFailedListener) zabqVar);
+        String contextAttributionTag = getContextAttributionTag();
+        if (contextAttributionTag != null && (buildClient instanceof BaseGmsClient)) {
+            ((BaseGmsClient) buildClient).setAttributionTag(contextAttributionTag);
+        }
+        if (contextAttributionTag != null && (buildClient instanceof NonGmsServiceBrokerClient)) {
+            ((NonGmsServiceBrokerClient) buildClient).zac(contextAttributionTag);
+        }
+        return buildClient;
+    }
+
+    public final zact zac(Context context, Handler handler) {
+        return new zact(context, handler, createClientSettingsBuilder().build());
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    @com.google.android.gms.common.annotation.KeepForSdk
+    @java.lang.Deprecated
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public GoogleApi(android.app.Activity r2, com.google.android.gms.common.api.Api<O> r3, O r4, com.google.android.gms.common.api.internal.StatusExceptionMapper r5) {
+        /*
+            r1 = this;
+            com.google.android.gms.common.api.GoogleApi$Settings$Builder r0 = new com.google.android.gms.common.api.GoogleApi$Settings$Builder
+            r0.<init>()
+            r0.setMapper(r5)
+            android.os.Looper r5 = r2.getMainLooper()
+            r0.setLooper(r5)
+            com.google.android.gms.common.api.GoogleApi$Settings r5 = r0.build()
+            r1.<init>(r2, r3, r4, r5)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.api.GoogleApi.<init>(android.app.Activity, com.google.android.gms.common.api.Api, com.google.android.gms.common.api.Api$ApiOptions, com.google.android.gms.common.api.internal.StatusExceptionMapper):void");
+    }
+
+    @KeepForSdk
+    public <TResult, A extends Api.AnyClient> Task<TResult> doBestEffortWrite(TaskApiCall<A, TResult> taskApiCall) {
+        return zae(2, taskApiCall);
+    }
+
+    @KeepForSdk
+    public <TResult, A extends Api.AnyClient> Task<TResult> doRead(TaskApiCall<A, TResult> taskApiCall) {
+        return zae(0, taskApiCall);
+    }
+
+    @KeepForSdk
+    public Task<Boolean> doUnregisterEventListener(ListenerHolder.ListenerKey<?> listenerKey, int i) {
+        Preconditions.checkNotNull(listenerKey, "Listener key cannot be null.");
+        return this.zaa.zar(this, listenerKey, i);
+    }
+
+    @KeepForSdk
+    public <TResult, A extends Api.AnyClient> Task<TResult> doWrite(TaskApiCall<A, TResult> taskApiCall) {
+        return zae(1, taskApiCall);
+    }
+
+    private GoogleApi(Context context, Activity activity, Api api, Api.ApiOptions apiOptions, Settings settings) {
+        Preconditions.checkNotNull(context, "Null context is not permitted.");
+        Preconditions.checkNotNull(api, "Api must not be null.");
+        Preconditions.checkNotNull(settings, "Settings must not be null; use Settings.DEFAULT_SETTINGS instead.");
+        this.zab = context.getApplicationContext();
+        String str = null;
+        if (PlatformVersion.isAtLeastR()) {
+            try {
+                str = (String) Context.class.getMethod("getAttributionTag", new Class[0]).invoke(context, new Object[0]);
+            } catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException unused) {
+            }
+        }
+        this.zac = str;
+        this.zad = api;
+        this.zae = apiOptions;
+        this.zag = settings.zab;
+        ApiKey sharedApiKey = ApiKey.getSharedApiKey(api, apiOptions, str);
+        this.zaf = sharedApiKey;
+        this.zai = new zabv(this);
+        GoogleApiManager zam = GoogleApiManager.zam(this.zab);
+        this.zaa = zam;
+        this.zah = zam.zaa();
+        this.zaj = settings.zaa;
+        if (activity != null && !(activity instanceof GoogleApiActivity) && Looper.myLooper() == Looper.getMainLooper()) {
+            zaae.zad(activity, zam, sharedApiKey);
+        }
+        zam.zaB(this);
+    }
+
+    @KeepForSdk
+    public <A extends Api.AnyClient> Task<Void> doRegisterEventListener(RegistrationMethods<A, ?> registrationMethods) {
+        Preconditions.checkNotNull(registrationMethods);
+        Preconditions.checkNotNull(registrationMethods.register.getListenerKey(), "Listener has already been released.");
+        Preconditions.checkNotNull(registrationMethods.zaa.getListenerKey(), "Listener has already been released.");
+        return this.zaa.zaq(this, registrationMethods.register, registrationMethods.zaa, registrationMethods.zab);
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    @com.google.android.gms.common.annotation.KeepForSdk
+    @java.lang.Deprecated
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public GoogleApi(android.content.Context r2, com.google.android.gms.common.api.Api<O> r3, O r4, android.os.Looper r5, com.google.android.gms.common.api.internal.StatusExceptionMapper r6) {
+        /*
+            r1 = this;
+            com.google.android.gms.common.api.GoogleApi$Settings$Builder r0 = new com.google.android.gms.common.api.GoogleApi$Settings$Builder
+            r0.<init>()
+            r0.setLooper(r5)
+            r0.setMapper(r6)
+            com.google.android.gms.common.api.GoogleApi$Settings r5 = r0.build()
+            r1.<init>(r2, r3, r4, r5)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.api.GoogleApi.<init>(android.content.Context, com.google.android.gms.common.api.Api, com.google.android.gms.common.api.Api$ApiOptions, android.os.Looper, com.google.android.gms.common.api.internal.StatusExceptionMapper):void");
+    }
+
+    @KeepForSdk
+    public GoogleApi(Context context, Api<O> api, O o4, Settings settings) {
+        this(context, (Activity) null, api, o4, settings);
+    }
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    @com.google.android.gms.common.annotation.KeepForSdk
+    @java.lang.Deprecated
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public GoogleApi(android.content.Context r2, com.google.android.gms.common.api.Api<O> r3, O r4, com.google.android.gms.common.api.internal.StatusExceptionMapper r5) {
+        /*
+            r1 = this;
+            com.google.android.gms.common.api.GoogleApi$Settings$Builder r0 = new com.google.android.gms.common.api.GoogleApi$Settings$Builder
+            r0.<init>()
+            r0.setMapper(r5)
+            com.google.android.gms.common.api.GoogleApi$Settings r5 = r0.build()
+            r1.<init>(r2, r3, r4, r5)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.api.GoogleApi.<init>(android.content.Context, com.google.android.gms.common.api.Api, com.google.android.gms.common.api.Api$ApiOptions, com.google.android.gms.common.api.internal.StatusExceptionMapper):void");
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/GoogleApiActivity.java

@@ -0,0 +1,135 @@
+package com.google.android.gms.common.api;
+
+import C.w;
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.os.Build;
+import android.os.Bundle;
+import android.util.Log;
+import com.google.android.gms.cloudmessaging.CloudMessagingReceiver;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.annotation.KeepName;
+import com.google.android.gms.common.api.internal.GoogleApiManager;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.VisibleForTesting;
+
+@KeepName
+/* loaded from: classes3.dex */
+public class GoogleApiActivity extends Activity implements DialogInterface.OnCancelListener {
+
+    @VisibleForTesting
+    protected int zaa = 0;
+
+    public static Intent zaa(Context context, PendingIntent pendingIntent, int i, boolean z3) {
+        Intent intent = new Intent(context, (Class<?>) GoogleApiActivity.class);
+        intent.putExtra(CloudMessagingReceiver.IntentKeys.PENDING_INTENT, pendingIntent);
+        intent.putExtra("failing_client_id", i);
+        intent.putExtra("notify_manager", z3);
+        return intent;
+    }
+
+    private final void zab() {
+        GoogleApiActivity googleApiActivity;
+        Bundle extras = getIntent().getExtras();
+        if (extras == null) {
+            Log.e("GoogleApiActivity", "Activity started without extras");
+            finish();
+            return;
+        }
+        PendingIntent pendingIntent = (PendingIntent) extras.get(CloudMessagingReceiver.IntentKeys.PENDING_INTENT);
+        Integer num = (Integer) extras.get("error_code");
+        if (pendingIntent == null && num == null) {
+            Log.e("GoogleApiActivity", "Activity started without resolution");
+            finish();
+            return;
+        }
+        if (pendingIntent == null) {
+            GoogleApiAvailability.getInstance().showErrorDialogFragment(this, ((Integer) Preconditions.checkNotNull(num)).intValue(), 2, this);
+            this.zaa = 1;
+            return;
+        }
+        try {
+            googleApiActivity = this;
+            try {
+                googleApiActivity.startIntentSenderForResult(pendingIntent.getIntentSender(), 1, null, 0, 0, 0);
+                googleApiActivity.zaa = 1;
+            } catch (ActivityNotFoundException e4) {
+                e = e4;
+                ActivityNotFoundException activityNotFoundException = e;
+                if (extras.getBoolean("notify_manager", true)) {
+                    GoogleApiManager.zam(googleApiActivity).zaz(new ConnectionResult(22, null), googleApiActivity.getIntent().getIntExtra("failing_client_id", -1));
+                } else {
+                    String o4 = w.o("Activity not found while launching ", pendingIntent.toString(), ".");
+                    if (Build.FINGERPRINT.contains("generic")) {
+                        o4 = o4.concat(" This may occur when resolving Google Play services connection issues on emulators with Google APIs but not Google Play Store.");
+                    }
+                    Log.e("GoogleApiActivity", o4, activityNotFoundException);
+                }
+                googleApiActivity.zaa = 1;
+                googleApiActivity.finish();
+            } catch (IntentSender.SendIntentException e5) {
+                e = e5;
+                Log.e("GoogleApiActivity", "Failed to launch pendingIntent", e);
+                googleApiActivity.finish();
+            }
+        } catch (ActivityNotFoundException e6) {
+            e = e6;
+            googleApiActivity = this;
+        } catch (IntentSender.SendIntentException e7) {
+            e = e7;
+            googleApiActivity = this;
+        }
+    }
+
+    @Override // android.app.Activity
+    public final void onActivityResult(int i, int i4, Intent intent) {
+        super.onActivityResult(i, i4, intent);
+        if (i == 1) {
+            boolean booleanExtra = getIntent().getBooleanExtra("notify_manager", true);
+            this.zaa = 0;
+            setResult(i4, intent);
+            if (booleanExtra) {
+                GoogleApiManager zam = GoogleApiManager.zam(this);
+                if (i4 == -1) {
+                    zam.zaA();
+                } else if (i4 == 0) {
+                    zam.zaz(new ConnectionResult(13, null), getIntent().getIntExtra("failing_client_id", -1));
+                }
+            }
+        } else if (i == 2) {
+            this.zaa = 0;
+            setResult(i4, intent);
+        }
+        finish();
+    }
+
+    @Override // android.content.DialogInterface.OnCancelListener
+    public final void onCancel(DialogInterface dialogInterface) {
+        this.zaa = 0;
+        setResult(0);
+        finish();
+    }
+
+    @Override // android.app.Activity
+    public final void onCreate(Bundle bundle) {
+        super.onCreate(bundle);
+        if (bundle != null) {
+            this.zaa = bundle.getInt("resolution");
+        }
+        if (this.zaa != 1) {
+            zab();
+        }
+    }
+
+    @Override // android.app.Activity
+    public final void onSaveInstanceState(Bundle bundle) {
+        bundle.putInt("resolution", this.zaa);
+        super.onSaveInstanceState(bundle);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/GoogleApiClient.java

@@ -0,0 +1,388 @@
+package com.google.android.gms.common.api;
+
+import C.w;
+import android.accounts.Account;
+import android.app.Activity;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.View;
+import androidx.fragment.app.P;
+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.Api;
+import com.google.android.gms.common.api.internal.BaseImplementation;
+import com.google.android.gms.common.api.internal.LifecycleActivity;
+import com.google.android.gms.common.api.internal.ListenerHolder;
+import com.google.android.gms.common.api.internal.SignInConnectionListener;
+import com.google.android.gms.common.api.internal.zabe;
+import com.google.android.gms.common.api.internal.zada;
+import com.google.android.gms.common.api.internal.zak;
+import com.google.android.gms.common.api.internal.zat;
+import com.google.android.gms.common.internal.AccountType;
+import com.google.android.gms.common.internal.ClientSettings;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.VisibleForTesting;
+import com.google.android.gms.signin.SignInOptions;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+import s.j;
+
+@Deprecated
+/* loaded from: classes3.dex */
+public abstract class GoogleApiClient {
+
+    @KeepForSdk
+    public static final String DEFAULT_ACCOUNT = "<<default account>>";
+    public static final int SIGN_IN_MODE_OPTIONAL = 2;
+    public static final int SIGN_IN_MODE_REQUIRED = 1;
+    private static final Set zaa = Collections.newSetFromMap(new WeakHashMap());
+
+    @Deprecated
+    /* loaded from: classes3.dex */
+    public interface ConnectionCallbacks extends com.google.android.gms.common.api.internal.ConnectionCallbacks {
+        public static final int CAUSE_NETWORK_LOST = 2;
+        public static final int CAUSE_SERVICE_DISCONNECTED = 1;
+    }
+
+    @Deprecated
+    /* loaded from: classes3.dex */
+    public interface OnConnectionFailedListener extends com.google.android.gms.common.api.internal.OnConnectionFailedListener {
+    }
+
+    public static void dumpAll(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        Set<GoogleApiClient> set = zaa;
+        synchronized (set) {
+            try {
+                String str2 = str + "  ";
+                int i = 0;
+                for (GoogleApiClient googleApiClient : set) {
+                    printWriter.append((CharSequence) str).append("GoogleApiClient#").println(i);
+                    googleApiClient.dump(str2, fileDescriptor, printWriter, strArr);
+                    i++;
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @KeepForSdk
+    public static Set<GoogleApiClient> getAllClients() {
+        Set<GoogleApiClient> set = zaa;
+        synchronized (set) {
+        }
+        return set;
+    }
+
+    public abstract ConnectionResult blockingConnect();
+
+    public abstract ConnectionResult blockingConnect(long j4, TimeUnit timeUnit);
+
+    public abstract PendingResult<Status> clearDefaultAccountAndReconnect();
+
+    public abstract void connect();
+
+    public void connect(int i) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract void disconnect();
+
+    public abstract void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr);
+
+    @KeepForSdk
+    public <A extends Api.AnyClient, R extends Result, T extends BaseImplementation.ApiMethodImpl<R, A>> T enqueue(T t2) {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T execute(T t2) {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public <C extends Api.Client> C getClient(Api.AnyClientKey<C> anyClientKey) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract ConnectionResult getConnectionResult(Api<?> api);
+
+    @KeepForSdk
+    public Context getContext() {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public Looper getLooper() {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public boolean hasApi(Api<?> api) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract boolean hasConnectedApi(Api<?> api);
+
+    public abstract boolean isConnected();
+
+    public abstract boolean isConnecting();
+
+    public abstract boolean isConnectionCallbacksRegistered(ConnectionCallbacks connectionCallbacks);
+
+    public abstract boolean isConnectionFailedListenerRegistered(OnConnectionFailedListener onConnectionFailedListener);
+
+    @KeepForSdk
+    public boolean maybeSignIn(SignInConnectionListener signInConnectionListener) {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public void maybeSignOut() {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract void reconnect();
+
+    public abstract void registerConnectionCallbacks(ConnectionCallbacks connectionCallbacks);
+
+    public abstract void registerConnectionFailedListener(OnConnectionFailedListener onConnectionFailedListener);
+
+    @KeepForSdk
+    public <L> ListenerHolder<L> registerListener(L l4) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract void stopAutoManage(P p);
+
+    public abstract void unregisterConnectionCallbacks(ConnectionCallbacks connectionCallbacks);
+
+    public abstract void unregisterConnectionFailedListener(OnConnectionFailedListener onConnectionFailedListener);
+
+    public void zao(zada zadaVar) {
+        throw new UnsupportedOperationException();
+    }
+
+    public void zap(zada zadaVar) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Deprecated
+    /* loaded from: classes3.dex */
+    public static final class Builder {
+        private Account zaa;
+        private final Set zab;
+        private final Set zac;
+        private int zad;
+        private View zae;
+        private String zaf;
+        private String zag;
+        private final Map zah;
+        private final Context zai;
+        private final Map zaj;
+        private LifecycleActivity zak;
+        private int zal;
+        private OnConnectionFailedListener zam;
+        private Looper zan;
+        private GoogleApiAvailability zao;
+        private Api.AbstractClientBuilder zap;
+        private final ArrayList zaq;
+        private final ArrayList zar;
+
+        /* JADX WARN: Type inference failed for: r0v2, types: [java.util.Map, s.j] */
+        /* JADX WARN: Type inference failed for: r0v3, types: [java.util.Map, s.j] */
+        public Builder(Context context) {
+            this.zab = new HashSet();
+            this.zac = new HashSet();
+            this.zah = new j(0);
+            this.zaj = new j(0);
+            this.zal = -1;
+            this.zao = GoogleApiAvailability.getInstance();
+            this.zap = com.google.android.gms.signin.zad.zac;
+            this.zaq = new ArrayList();
+            this.zar = new ArrayList();
+            this.zai = context;
+            this.zan = context.getMainLooper();
+            this.zaf = context.getPackageName();
+            this.zag = context.getClass().getName();
+        }
+
+        private final void zab(Api api, Api.ApiOptions apiOptions, Scope... scopeArr) {
+            HashSet hashSet = new HashSet(((Api.BaseClientBuilder) Preconditions.checkNotNull(api.zac(), "Base client builder must not be null")).getImpliedScopes(apiOptions));
+            for (Scope scope : scopeArr) {
+                hashSet.add(scope);
+            }
+            this.zah.put(api, new com.google.android.gms.common.internal.zab(hashSet));
+        }
+
+        public Builder addApi(Api<? extends Api.ApiOptions.NotRequiredOptions> api) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            this.zaj.put(api, null);
+            List<Scope> impliedScopes = ((Api.BaseClientBuilder) Preconditions.checkNotNull(api.zac(), "Base client builder must not be null")).getImpliedScopes(null);
+            this.zac.addAll(impliedScopes);
+            this.zab.addAll(impliedScopes);
+            return this;
+        }
+
+        public <O extends Api.ApiOptions.HasOptions> Builder addApiIfAvailable(Api<O> api, O o4, Scope... scopeArr) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            Preconditions.checkNotNull(o4, "Null options are not permitted for this Api");
+            this.zaj.put(api, o4);
+            zab(api, o4, scopeArr);
+            return this;
+        }
+
+        public Builder addConnectionCallbacks(ConnectionCallbacks connectionCallbacks) {
+            Preconditions.checkNotNull(connectionCallbacks, "Listener must not be null");
+            this.zaq.add(connectionCallbacks);
+            return this;
+        }
+
+        public Builder addOnConnectionFailedListener(OnConnectionFailedListener onConnectionFailedListener) {
+            Preconditions.checkNotNull(onConnectionFailedListener, "Listener must not be null");
+            this.zar.add(onConnectionFailedListener);
+            return this;
+        }
+
+        public Builder addScope(Scope scope) {
+            Preconditions.checkNotNull(scope, "Scope must not be null");
+            this.zab.add(scope);
+            return this;
+        }
+
+        /* JADX WARN: Type inference failed for: r11v0, types: [java.util.Map, s.j] */
+        /* JADX WARN: Type inference failed for: r14v0, types: [java.util.Map, s.e, s.j] */
+        public GoogleApiClient build() {
+            Preconditions.checkArgument(!this.zaj.isEmpty(), "must call addApi() to add at least one API");
+            ClientSettings zaa = zaa();
+            Map zad = zaa.zad();
+            ?? jVar = new j(0);
+            ?? jVar2 = new j(0);
+            ArrayList arrayList = new ArrayList();
+            boolean z3 = false;
+            Api api = null;
+            for (Api api2 : this.zaj.keySet()) {
+                Object obj = this.zaj.get(api2);
+                boolean z4 = zad.get(api2) != null;
+                jVar.put(api2, Boolean.valueOf(z4));
+                zat zatVar = new zat(api2, z4);
+                arrayList.add(zatVar);
+                Api.AbstractClientBuilder abstractClientBuilder = (Api.AbstractClientBuilder) Preconditions.checkNotNull(api2.zaa());
+                Api.Client buildClient = abstractClientBuilder.buildClient(this.zai, this.zan, zaa, (ClientSettings) obj, (ConnectionCallbacks) zatVar, (OnConnectionFailedListener) zatVar);
+                jVar2.put(api2.zab(), buildClient);
+                if (abstractClientBuilder.getPriority() == 1) {
+                    z3 = obj != null;
+                }
+                if (buildClient.providesSignIn()) {
+                    if (api != null) {
+                        throw new IllegalStateException(api2.zad() + " cannot be used with " + api.zad());
+                    }
+                    api = api2;
+                }
+            }
+            if (api != null) {
+                if (z3) {
+                    throw new IllegalStateException(w.o("With using ", api.zad(), ", GamesOptions can only be specified within GoogleSignInOptions.Builder"));
+                }
+                Preconditions.checkState(this.zaa == null, "Must not set an account in GoogleApiClient.Builder when using %s. Set account in GoogleSignInOptions.Builder instead", api.zad());
+                Preconditions.checkState(this.zab.equals(this.zac), "Must not set scopes in GoogleApiClient.Builder when using %s. Set account in GoogleSignInOptions.Builder instead.", api.zad());
+            }
+            zabe zabeVar = new zabe(this.zai, new ReentrantLock(), this.zan, zaa, this.zao, this.zap, jVar, this.zaq, this.zar, jVar2, this.zal, zabe.zad(jVar2.values(), true), arrayList);
+            synchronized (GoogleApiClient.zaa) {
+                GoogleApiClient.zaa.add(zabeVar);
+            }
+            if (this.zal >= 0) {
+                zak.zaa(this.zak).zad(this.zal, zabeVar, this.zam);
+            }
+            return zabeVar;
+        }
+
+        public Builder enableAutoManage(P p, int i, OnConnectionFailedListener onConnectionFailedListener) {
+            LifecycleActivity lifecycleActivity = new LifecycleActivity((Activity) p);
+            Preconditions.checkArgument(i >= 0, "clientId must be non-negative");
+            this.zal = i;
+            this.zam = onConnectionFailedListener;
+            this.zak = lifecycleActivity;
+            return this;
+        }
+
+        public Builder setAccountName(String str) {
+            this.zaa = str == null ? null : new Account(str, AccountType.GOOGLE);
+            return this;
+        }
+
+        public Builder setGravityForPopups(int i) {
+            this.zad = i;
+            return this;
+        }
+
+        public Builder setHandler(Handler handler) {
+            Preconditions.checkNotNull(handler, "Handler must not be null");
+            this.zan = handler.getLooper();
+            return this;
+        }
+
+        public Builder setViewForPopups(View view) {
+            Preconditions.checkNotNull(view, "View must not be null");
+            this.zae = view;
+            return this;
+        }
+
+        public Builder useDefaultAccount() {
+            setAccountName("<<default account>>");
+            return this;
+        }
+
+        @VisibleForTesting
+        public final ClientSettings zaa() {
+            SignInOptions signInOptions = SignInOptions.zaa;
+            Map map = this.zaj;
+            Api api = com.google.android.gms.signin.zad.zag;
+            if (map.containsKey(api)) {
+                signInOptions = (SignInOptions) this.zaj.get(api);
+            }
+            return new ClientSettings(this.zaa, this.zab, this.zah, this.zad, this.zae, this.zaf, this.zag, signInOptions, false);
+        }
+
+        public Builder enableAutoManage(P p, OnConnectionFailedListener onConnectionFailedListener) {
+            enableAutoManage(p, 0, onConnectionFailedListener);
+            return this;
+        }
+
+        public <T extends Api.ApiOptions.NotRequiredOptions> Builder addApiIfAvailable(Api<? extends Api.ApiOptions.NotRequiredOptions> api, Scope... scopeArr) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            this.zaj.put(api, null);
+            zab(api, null, scopeArr);
+            return this;
+        }
+
+        public <O extends Api.ApiOptions.HasOptions> Builder addApi(Api<O> api, O o4) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            Preconditions.checkNotNull(o4, "Null options are not permitted for this Api");
+            this.zaj.put(api, o4);
+            List<Scope> impliedScopes = ((Api.BaseClientBuilder) Preconditions.checkNotNull(api.zac(), "Base client builder must not be null")).getImpliedScopes(o4);
+            this.zac.addAll(impliedScopes);
+            this.zab.addAll(impliedScopes);
+            return this;
+        }
+
+        public Builder(Context context, ConnectionCallbacks connectionCallbacks, OnConnectionFailedListener onConnectionFailedListener) {
+            this(context);
+            Preconditions.checkNotNull(connectionCallbacks, "Must provide a connected listener");
+            this.zaq.add(connectionCallbacks);
+            Preconditions.checkNotNull(onConnectionFailedListener, "Must provide a connection failed listener");
+            this.zar.add(onConnectionFailedListener);
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/HasApiKey.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.common.api;
+
+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.api.internal.ApiKey;
+
+/* loaded from: classes3.dex */
+public interface HasApiKey<O extends Api.ApiOptions> {
+    @KeepForSdk
+    ApiKey<O> getApiKey();
+}

apk_decompiled/sources/com/google/android/gms/common/api/OptionalModuleApi.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+/* loaded from: classes3.dex */
+public interface OptionalModuleApi {
+    @KeepForSdk
+    Feature[] getOptionalFeatures();
+}

apk_decompiled/sources/com/google/android/gms/common/api/OptionalPendingResult.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.Result;
+
+/* loaded from: classes3.dex */
+public abstract class OptionalPendingResult<R extends Result> extends PendingResult<R> {
+    public abstract R get();
+
+    public abstract boolean isDone();
+}

apk_decompiled/sources/com/google/android/gms/common/api/PendingResult.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Result;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+public abstract class PendingResult<R extends Result> {
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public interface StatusListener {
+        @KeepForSdk
+        void onComplete(Status status);
+    }
+
+    @KeepForSdk
+    public void addStatusListener(StatusListener statusListener) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract R await();
+
+    public abstract R await(long j4, TimeUnit timeUnit);
+
+    public abstract void cancel();
+
+    public abstract boolean isCanceled();
+
+    public abstract void setResultCallback(ResultCallback<? super R> resultCallback);
+
+    public abstract void setResultCallback(ResultCallback<? super R> resultCallback, long j4, TimeUnit timeUnit);
+
+    public <S extends Result> TransformedResult<S> then(ResultTransform<? super R, ? extends S> resultTransform) {
+        throw new UnsupportedOperationException();
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/PendingResults.java

@@ -0,0 +1,66 @@
+package com.google.android.gms.common.api;
+
+import android.os.Looper;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.internal.OptionalPendingResultImpl;
+import com.google.android.gms.common.api.internal.StatusPendingResult;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public final class PendingResults {
+    private PendingResults() {
+    }
+
+    public static PendingResult<Status> canceledPendingResult() {
+        StatusPendingResult statusPendingResult = new StatusPendingResult(Looper.getMainLooper());
+        statusPendingResult.cancel();
+        return statusPendingResult;
+    }
+
+    @KeepForSdk
+    public static <R extends Result> PendingResult<R> immediateFailedResult(R r4, GoogleApiClient googleApiClient) {
+        Preconditions.checkNotNull(r4, "Result must not be null");
+        Preconditions.checkArgument(!r4.getStatus().isSuccess(), "Status code must not be SUCCESS");
+        zag zagVar = new zag(googleApiClient, r4);
+        zagVar.setResult(r4);
+        return zagVar;
+    }
+
+    public static <R extends Result> OptionalPendingResult<R> immediatePendingResult(R r4) {
+        Preconditions.checkNotNull(r4, "Result must not be null");
+        zah zahVar = new zah(null);
+        zahVar.setResult(r4);
+        return new OptionalPendingResultImpl(zahVar);
+    }
+
+    public static <R extends Result> PendingResult<R> canceledPendingResult(R r4) {
+        Preconditions.checkNotNull(r4, "Result must not be null");
+        Preconditions.checkArgument(r4.getStatus().getStatusCode() == 16, "Status code must be CommonStatusCodes.CANCELED");
+        zaf zafVar = new zaf(r4);
+        zafVar.cancel();
+        return zafVar;
+    }
+
+    @KeepForSdk
+    public static <R extends Result> OptionalPendingResult<R> immediatePendingResult(R r4, GoogleApiClient googleApiClient) {
+        Preconditions.checkNotNull(r4, "Result must not be null");
+        zah zahVar = new zah(googleApiClient);
+        zahVar.setResult(r4);
+        return new OptionalPendingResultImpl(zahVar);
+    }
+
+    public static PendingResult<Status> immediatePendingResult(Status status) {
+        Preconditions.checkNotNull(status, "Result must not be null");
+        StatusPendingResult statusPendingResult = new StatusPendingResult(Looper.getMainLooper());
+        statusPendingResult.setResult(status);
+        return statusPendingResult;
+    }
+
+    @KeepForSdk
+    public static PendingResult<Status> immediatePendingResult(Status status, GoogleApiClient googleApiClient) {
+        Preconditions.checkNotNull(status, "Result must not be null");
+        StatusPendingResult statusPendingResult = new StatusPendingResult(googleApiClient);
+        statusPendingResult.setResult(status);
+        return statusPendingResult;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/Releasable.java

@@ -0,0 +1,6 @@
+package com.google.android.gms.common.api;
+
+/* loaded from: classes3.dex */
+public interface Releasable {
+    void release();
+}

apk_decompiled/sources/com/google/android/gms/common/api/ResolvableApiException.java

@@ -0,0 +1,20 @@
+package com.google.android.gms.common.api;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.IntentSender;
+
+/* loaded from: classes3.dex */
+public class ResolvableApiException extends ApiException {
+    public ResolvableApiException(Status status) {
+        super(status);
+    }
+
+    public PendingIntent getResolution() {
+        return getStatus().getResolution();
+    }
+
+    public void startResolutionForResult(Activity activity, int i) throws IntentSender.SendIntentException {
+        getStatus().startResolutionForResult(activity, i);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/ResolvingResultCallbacks.java

@@ -0,0 +1,40 @@
+package com.google.android.gms.common.api;
+
+import android.app.Activity;
+import android.content.IntentSender;
+import android.util.Log;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public abstract class ResolvingResultCallbacks<R extends Result> extends ResultCallbacks<R> {
+    private final Activity zza;
+    private final int zzb;
+
+    public ResolvingResultCallbacks(Activity activity, int i) {
+        Preconditions.checkNotNull(activity, "Activity must not be null");
+        this.zza = activity;
+        this.zzb = i;
+    }
+
+    @Override // com.google.android.gms.common.api.ResultCallbacks
+    @KeepForSdk
+    public final void onFailure(Status status) {
+        if (!status.hasResolution()) {
+            onUnresolvableFailure(status);
+            return;
+        }
+        try {
+            status.startResolutionForResult(this.zza, this.zzb);
+        } catch (IntentSender.SendIntentException e4) {
+            Log.e("ResolvingResultCallback", "Failed to start resolution", e4);
+            onUnresolvableFailure(new Status(8));
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.ResultCallbacks
+    public abstract void onSuccess(R r4);
+
+    public abstract void onUnresolvableFailure(Status status);
+}

apk_decompiled/sources/com/google/android/gms/common/api/Response.java

@@ -0,0 +1,23 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.Result;
+
+/* loaded from: classes3.dex */
+public class Response<T extends Result> {
+    private Result zza;
+
+    public Response() {
+    }
+
+    public T getResult() {
+        return (T) this.zza;
+    }
+
+    public void setResult(T t2) {
+        this.zza = t2;
+    }
+
+    public Response(T t2) {
+        this.zza = t2;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/Result.java

@@ -0,0 +1,6 @@
+package com.google.android.gms.common.api;
+
+/* loaded from: classes3.dex */
+public interface Result {
+    Status getStatus();
+}

apk_decompiled/sources/com/google/android/gms/common/api/ResultCallback.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.Result;
+
+/* loaded from: classes3.dex */
+public interface ResultCallback<R extends Result> {
+    void onResult(R r4);
+}

apk_decompiled/sources/com/google/android/gms/common/api/ResultCallbacks.java

@@ -0,0 +1,30 @@
+package com.google.android.gms.common.api;
+
+import android.util.Log;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Result;
+
+/* loaded from: classes3.dex */
+public abstract class ResultCallbacks<R extends Result> implements ResultCallback<R> {
+    public abstract void onFailure(Status status);
+
+    @Override // com.google.android.gms.common.api.ResultCallback
+    @KeepForSdk
+    public final void onResult(R r4) {
+        Status status = r4.getStatus();
+        if (status.isSuccess()) {
+            onSuccess(r4);
+            return;
+        }
+        onFailure(status);
+        if (r4 instanceof Releasable) {
+            try {
+                ((Releasable) r4).release();
+            } catch (RuntimeException e4) {
+                Log.w("ResultCallbacks", "Unable to release ".concat(String.valueOf(r4)), e4);
+            }
+        }
+    }
+
+    public abstract void onSuccess(R r4);
+}

apk_decompiled/sources/com/google/android/gms/common/api/ResultTransform.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.Result;
+import com.google.android.gms.common.api.internal.zacp;
+
+/* loaded from: classes3.dex */
+public abstract class ResultTransform<R extends Result, S extends Result> {
+    public final PendingResult<S> createFailedResult(Status status) {
+        return new zacp(status);
+    }
+
+    public Status onFailure(Status status) {
+        return status;
+    }
+
+    public abstract PendingResult<S> onSuccess(R r4);
+}

apk_decompiled/sources/com/google/android/gms/common/api/Scope.java

@@ -0,0 +1,64 @@
+package com.google.android.gms.common.api;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ReflectedParcelable;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+
+@SafeParcelable.Class(creator = "ScopeCreator")
+/* loaded from: classes3.dex */
+public final class Scope extends AbstractSafeParcelable implements ReflectedParcelable {
+    public static final Parcelable.Creator<Scope> CREATOR = new zza();
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zza;
+
+    @SafeParcelable.Field(getter = "getScopeUri", id = 2)
+    private final String zzb;
+
+    @SafeParcelable.Constructor
+    public Scope(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) String str) {
+        Preconditions.checkNotEmpty(str, "scopeUri must not be null or empty");
+        this.zza = i;
+        this.zzb = str;
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof Scope) {
+            return this.zzb.equals(((Scope) obj).zzb);
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    public String getScopeUri() {
+        return this.zzb;
+    }
+
+    public int hashCode() {
+        return this.zzb.hashCode();
+    }
+
+    public String toString() {
+        return this.zzb;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zza);
+        SafeParcelWriter.writeString(parcel, 2, getScopeUri(), false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public Scope(String str) {
+        this(1, str);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/Status.java

@@ -0,0 +1,182 @@
+package com.google.android.gms.common.api;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.IntentSender;
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Objects;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ReflectedParcelable;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.safeparcel.AbstractSafeParcelable;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelWriter;
+import com.google.android.gms.common.internal.safeparcel.SafeParcelable;
+import com.google.android.gms.common.util.VisibleForTesting;
+
+@SafeParcelable.Class(creator = "StatusCreator")
+/* loaded from: classes3.dex */
+public final class Status extends AbstractSafeParcelable implements Result, ReflectedParcelable {
+
+    @SafeParcelable.VersionField(id = 1000)
+    final int zzb;
+
+    @SafeParcelable.Field(getter = "getStatusCode", id = 1)
+    private final int zzc;
+
+    @SafeParcelable.Field(getter = "getStatusMessage", id = 2)
+    private final String zzd;
+
+    @SafeParcelable.Field(getter = "getPendingIntent", id = 3)
+    private final PendingIntent zze;
+
+    @SafeParcelable.Field(getter = "getConnectionResult", id = 4)
+    private final ConnectionResult zzf;
+
+    @ShowFirstParty
+    @VisibleForTesting
+    @KeepForSdk
+    public static final Status RESULT_SUCCESS_CACHE = new Status(-1);
+
+    @ShowFirstParty
+    @VisibleForTesting
+    @KeepForSdk
+    public static final Status RESULT_SUCCESS = new Status(0);
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_INTERRUPTED = new Status(14);
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_INTERNAL_ERROR = new Status(8);
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_TIMEOUT = new Status(15);
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_CANCELED = new Status(16);
+
+    @ShowFirstParty
+    public static final Status zza = new Status(17);
+
+    @KeepForSdk
+    public static final Status RESULT_DEAD_CLIENT = new Status(18);
+    public static final Parcelable.Creator<Status> CREATOR = new zzb();
+
+    @SafeParcelable.Constructor
+    public Status(@SafeParcelable.Param(id = 1000) int i, @SafeParcelable.Param(id = 1) int i4, @SafeParcelable.Param(id = 2) String str, @SafeParcelable.Param(id = 3) PendingIntent pendingIntent, @SafeParcelable.Param(id = 4) ConnectionResult connectionResult) {
+        this.zzb = i;
+        this.zzc = i4;
+        this.zzd = str;
+        this.zze = pendingIntent;
+        this.zzf = connectionResult;
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Status)) {
+            return false;
+        }
+        Status status = (Status) obj;
+        return this.zzb == status.zzb && this.zzc == status.zzc && Objects.equal(this.zzd, status.zzd) && Objects.equal(this.zze, status.zze) && Objects.equal(this.zzf, status.zzf);
+    }
+
+    public ConnectionResult getConnectionResult() {
+        return this.zzf;
+    }
+
+    public PendingIntent getResolution() {
+        return this.zze;
+    }
+
+    @Override // com.google.android.gms.common.api.Result
+    public Status getStatus() {
+        return this;
+    }
+
+    public int getStatusCode() {
+        return this.zzc;
+    }
+
+    public String getStatusMessage() {
+        return this.zzd;
+    }
+
+    @VisibleForTesting
+    public boolean hasResolution() {
+        return this.zze != null;
+    }
+
+    public int hashCode() {
+        return Objects.hashCode(Integer.valueOf(this.zzb), Integer.valueOf(this.zzc), this.zzd, this.zze, this.zzf);
+    }
+
+    public boolean isCanceled() {
+        return this.zzc == 16;
+    }
+
+    public boolean isInterrupted() {
+        return this.zzc == 14;
+    }
+
+    public boolean isSuccess() {
+        return this.zzc <= 0;
+    }
+
+    public void startResolutionForResult(Activity activity, int i) throws IntentSender.SendIntentException {
+        if (hasResolution()) {
+            PendingIntent pendingIntent = this.zze;
+            Preconditions.checkNotNull(pendingIntent);
+            activity.startIntentSenderForResult(pendingIntent.getIntentSender(), i, null, 0, 0, 0);
+        }
+    }
+
+    public String toString() {
+        Objects.ToStringHelper stringHelper = Objects.toStringHelper(this);
+        stringHelper.add("statusCode", zza());
+        stringHelper.add("resolution", this.zze);
+        return stringHelper.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, getStatusCode());
+        SafeParcelWriter.writeString(parcel, 2, getStatusMessage(), false);
+        SafeParcelWriter.writeParcelable(parcel, 3, this.zze, i, false);
+        SafeParcelWriter.writeParcelable(parcel, 4, getConnectionResult(), i, false);
+        SafeParcelWriter.writeInt(parcel, 1000, this.zzb);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public final String zza() {
+        String str = this.zzd;
+        return str != null ? str : CommonStatusCodes.getStatusCodeString(this.zzc);
+    }
+
+    public Status(int i) {
+        this(i, (String) null);
+    }
+
+    public Status(int i, String str) {
+        this(1, i, str, null, null);
+    }
+
+    public Status(int i, String str, PendingIntent pendingIntent) {
+        this(1, i, str, pendingIntent, null);
+    }
+
+    public Status(ConnectionResult connectionResult, String str) {
+        this(connectionResult, str, 17);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public Status(ConnectionResult connectionResult, String str, int i) {
+        this(1, i, str, connectionResult.getResolution(), connectionResult);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/TransformedResult.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.api.Result;
+
+/* loaded from: classes3.dex */
+public abstract class TransformedResult<R extends Result> {
+    public abstract void andFinally(ResultCallbacks<? super R> resultCallbacks);
+
+    public abstract <S extends Result> TransformedResult<S> then(ResultTransform<? super R, ? extends S> resultTransform);
+}

apk_decompiled/sources/com/google/android/gms/common/api/UnsupportedApiCallException.java

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.api;
+
+import com.google.android.gms.common.Feature;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+/* loaded from: classes3.dex */
+public final class UnsupportedApiCallException extends UnsupportedOperationException {
+    private final Feature zza;
+
+    @KeepForSdk
+    public UnsupportedApiCallException(Feature feature) {
+        this.zza = feature;
+    }
+
+    @Override // java.lang.Throwable
+    public String getMessage() {
+        return "Missing ".concat(String.valueOf(this.zza));
+    }
+}

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

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

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

@@ -0,0 +1,14 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public class ApiExceptionMapper implements StatusExceptionMapper {
+    @Override // com.google.android.gms.common.api.internal.StatusExceptionMapper
+    public final Exception getException(Status status) {
+        return ApiExceptionUtil.fromStatus(status);
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public final class ApiKey<O extends Api.ApiOptions> {
+    private final int zaa;
+    private final Api zab;
+    private final Api.ApiOptions zac;
+    private final String zad;
+
+    private ApiKey(Api api, Api.ApiOptions apiOptions, String str) {
+        this.zab = api;
+        this.zac = apiOptions;
+        this.zad = str;
+        this.zaa = Objects.hashCode(api, apiOptions, str);
+    }
+
+    @KeepForSdk
+    public static <O extends Api.ApiOptions> ApiKey<O> getSharedApiKey(Api<O> api, O o4, String str) {
+        return new ApiKey<>(api, o4, str);
+    }
+
+    public final boolean equals(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;
+    }
+
+    public final String zaa() {
+        return this.zab.zad();
+    }
+}

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

@@ -0,0 +1,151 @@
+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 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: classes3.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
+    /* loaded from: classes3.dex */
+    public interface BackgroundStateChangeListener {
+        @KeepForSdk
+        void onBackgroundStateChanged(boolean z3);
+    }
+
+    @KeepForSdk
+    private BackgroundDetector() {
+    }
+
+    @KeepForSdk
+    public static BackgroundDetector getInstance() {
+        return zza;
+    }
+
+    @KeepForSdk
+    public static void initialize(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 z3) {
+        synchronized (zza) {
+            try {
+                Iterator it = this.zzd.iterator();
+                while (it.hasNext()) {
+                    ((BackgroundStateChangeListener) it.next()).onBackgroundStateChanged(z3);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @KeepForSdk
+    public void addListener(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(Activity activity, Bundle bundle) {
+        boolean compareAndSet = this.zzb.compareAndSet(true, false);
+        this.zzc.set(true);
+        if (compareAndSet) {
+            zza(false);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityDestroyed(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityPaused(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityResumed(Activity activity) {
+        boolean compareAndSet = this.zzb.compareAndSet(true, false);
+        this.zzc.set(true);
+        if (compareAndSet) {
+            zza(false);
+        }
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityStarted(Activity activity) {
+    }
+
+    @Override // android.app.Application.ActivityLifecycleCallbacks
+    public final void onActivityStopped(Activity activity) {
+    }
+
+    @Override // android.content.ComponentCallbacks
+    public final void onConfigurationChanged(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 z3) {
+        if (!this.zzc.get()) {
+            if (!PlatformVersion.isAtLeastJellyBean()) {
+                return z3;
+            }
+            ActivityManager.RunningAppProcessInfo runningAppProcessInfo = new ActivityManager.RunningAppProcessInfo();
+            ActivityManager.getMyMemoryState(runningAppProcessInfo);
+            if (!this.zzc.getAndSet(true) && runningAppProcessInfo.importance > 100) {
+                this.zzb.set(true);
+            }
+        }
+        return isInBackground();
+    }
+}

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

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

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

@@ -0,0 +1,426 @@
+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 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.android.gms.common.util.VisibleForTesting;
+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: classes3.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 mResultGuardian;
+    protected final CallbackHandler zab;
+    protected final WeakReference zac;
+    private final Object zae;
+    private final CountDownLatch zaf;
+    private final ArrayList zag;
+    private ResultCallback zah;
+    private final AtomicReference zai;
+    private Result zaj;
+    private Status zak;
+    private volatile boolean zal;
+    private boolean zam;
+    private boolean zan;
+    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();
+        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.mResultGuardian = new zas(this, null);
+            }
+        }
+        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(Result result) {
+        if (result instanceof Releasable) {
+            try {
+                ((Releasable) result).release();
+            } catch (RuntimeException e4) {
+                Log.w("BasePendingResult", "Unable to release ".concat(String.valueOf(result)), e4);
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void addStatusListener(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
+    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));
+            }
+        }
+    }
+
+    @KeepForSdk
+    public abstract R createFailedResult(Status status);
+
+    @KeepForSdk
+    @Deprecated
+    public final void forceFailureUnlessReady(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 z3;
+        synchronized (this.zae) {
+            z3 = this.zam;
+        }
+        return z3;
+    }
+
+    @KeepForSdk
+    public final boolean isReady() {
+        return this.zaf.getCount() == 0;
+    }
+
+    @KeepForSdk
+    public final void setCancelToken(ICancelToken iCancelToken) {
+        synchronized (this.zae) {
+            this.zao = iCancelToken;
+        }
+    }
+
+    @KeepForSdk
+    public final void setResult(R r4) {
+        synchronized (this.zae) {
+            try {
+                if (this.zan || this.zam) {
+                    zal(r4);
+                    return;
+                }
+                isReady();
+                Preconditions.checkState(!isReady(), "Results have already been set");
+                Preconditions.checkState(!this.zal, "Result has already been consumed");
+                zab(r4);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    @KeepForSdk
+    public final void setResultCallback(ResultCallback<? super R> resultCallback) {
+        synchronized (this.zae) {
+            try {
+                if (resultCallback == null) {
+                    this.zah = null;
+                    return;
+                }
+                boolean z3 = true;
+                Preconditions.checkState(!this.zal, "Result has already been consumed.");
+                if (this.zap != null) {
+                    z3 = false;
+                }
+                Preconditions.checkState(z3, "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
+    public final <S extends Result> TransformedResult<S> then(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 z3 = true;
+        if (!this.zaq && !((Boolean) zaa.get()).booleanValue()) {
+            z3 = false;
+        }
+        this.zaq = z3;
+    }
+
+    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(zadb zadbVar) {
+        this.zai.set(zadbVar);
+    }
+
+    @VisibleForTesting
+    /* loaded from: classes3.dex */
+    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(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 e4) {
+                BasePendingResult.zal(result);
+                throw e4;
+            }
+        }
+
+        public final void zaa(ResultCallback resultCallback, Result result) {
+            int i = BasePendingResult.zad;
+            sendMessage(obtainMessage(1, new Pair((ResultCallback) Preconditions.checkNotNull(resultCallback), result)));
+        }
+
+        public CallbackHandler(Looper looper) {
+            super(looper);
+        }
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public BasePendingResult(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
+    public final R await(long j4, TimeUnit timeUnit) {
+        if (j4 > 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(j4, 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(ResultCallback<? super R> resultCallback, long j4, TimeUnit timeUnit) {
+        synchronized (this.zae) {
+            try {
+                if (resultCallback == null) {
+                    this.zah = null;
+                    return;
+                }
+                boolean z3 = true;
+                Preconditions.checkState(!this.zal, "Result has already been consumed.");
+                if (this.zap != null) {
+                    z3 = false;
+                }
+                Preconditions.checkState(z3, "Cannot set callbacks if then() has been called.");
+                if (isCanceled()) {
+                    return;
+                }
+                if (isReady()) {
+                    this.zab.zaa(resultCallback, zaa());
+                } else {
+                    this.zah = resultCallback;
+                    CallbackHandler callbackHandler = this.zab;
+                    callbackHandler.sendMessageDelayed(callbackHandler.obtainMessage(2, this), timeUnit.toMillis(j4));
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @KeepForSdk
+    public BasePendingResult(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);
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    public BasePendingResult(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);
+    }
+}

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

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

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

@@ -0,0 +1,34 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public abstract class DataHolderNotifier<L> implements ListenerHolder.Notifier<L> {
+    private final DataHolder zaa;
+
+    @KeepForSdk
+    public DataHolderNotifier(DataHolder dataHolder) {
+        this.zaa = dataHolder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.ListenerHolder.Notifier
+    @KeepForSdk
+    public final void notifyListener(L l4) {
+        notifyListener(l4, this.zaa);
+    }
+
+    @KeepForSdk
+    public abstract void notifyListener(L l4, 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();
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public abstract class DataHolderResult implements Result, Releasable {
+
+    @KeepForSdk
+    protected final DataHolder mDataHolder;
+
+    @KeepForSdk
+    protected final Status mStatus;
+
+    @KeepForSdk
+    public DataHolderResult(DataHolder dataHolder, Status status) {
+        this.mStatus = status;
+        this.mDataHolder = dataHolder;
+    }
+
+    @Override // com.google.android.gms.common.api.Result
+    @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();
+        }
+    }
+
+    @KeepForSdk
+    public DataHolderResult(DataHolder dataHolder) {
+        this(dataHolder, new Status(dataHolder.getStatusCode()));
+    }
+}

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

@@ -0,0 +1,476 @@
+package com.google.android.gms.common.api.internal;
+
+import C.w;
+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 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 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;
+import org.checkerframework.checker.initialization.qual.NotOnlyInitialized;
+import s.f;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class GoogleApiManager implements Handler.Callback {
+    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();
+    private static GoogleApiManager zad;
+    private TelemetryData zai;
+    private TelemetryLoggingClient zaj;
+    private final Context zak;
+    private final GoogleApiAvailability zal;
+    private final com.google.android.gms.common.internal.zal zam;
+
+    @NotOnlyInitialized
+    private final Handler zat;
+    private volatile boolean zau;
+    private long zae = 5000;
+    private long zaf = 120000;
+    private long zag = 10000;
+    private boolean zah = false;
+    private final AtomicInteger zan = new AtomicInteger(1);
+    private final AtomicInteger zao = new AtomicInteger(0);
+    private final Map zap = new ConcurrentHashMap(5, 0.75f, 1);
+    private zaae zaq = null;
+    private final Set zar = new f(0);
+    private final Set zas = new f(0);
+
+    @KeepForSdk
+    private GoogleApiManager(Context context, Looper looper, GoogleApiAvailability googleApiAvailability) {
+        this.zau = true;
+        this.zak = context;
+        com.google.android.gms.internal.base.zau zauVar = new com.google.android.gms.internal.base.zau(looper, this);
+        this.zat = zauVar;
+        this.zal = googleApiAvailability;
+        this.zam = new com.google.android.gms.common.internal.zal(googleApiAvailability);
+        if (DeviceProperties.isAuto(context)) {
+            this.zau = false;
+        }
+        zauVar.sendMessage(zauVar.obtainMessage(6));
+    }
+
+    @KeepForSdk
+    public static void reportSignOut() {
+        synchronized (zac) {
+            try {
+                GoogleApiManager googleApiManager = zad;
+                if (googleApiManager != null) {
+                    googleApiManager.zao.incrementAndGet();
+                    Handler handler = googleApiManager.zat;
+                    handler.sendMessageAtFrontOfQueue(handler.obtainMessage(10));
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static Status zaH(ApiKey apiKey, ConnectionResult connectionResult) {
+        return new Status(connectionResult, "API: " + apiKey.zaa() + " is not available on this device. Connection failed with: " + String.valueOf(connectionResult));
+    }
+
+    private final zabq zaI(GoogleApi googleApi) {
+        ApiKey apiKey = googleApi.getApiKey();
+        zabq zabqVar = (zabq) this.zap.get(apiKey);
+        if (zabqVar == null) {
+            zabqVar = new zabq(this, googleApi);
+            this.zap.put(apiKey, zabqVar);
+        }
+        if (zabqVar.zaz()) {
+            this.zas.add(apiKey);
+        }
+        zabqVar.zao();
+        return zabqVar;
+    }
+
+    private final TelemetryLoggingClient zaJ() {
+        if (this.zaj == null) {
+            this.zaj = TelemetryLogging.getClient(this.zak);
+        }
+        return this.zaj;
+    }
+
+    private final void zaK() {
+        TelemetryData telemetryData = this.zai;
+        if (telemetryData != null) {
+            if (telemetryData.zaa() > 0 || zaF()) {
+                zaJ().log(telemetryData);
+            }
+            this.zai = null;
+        }
+    }
+
+    private final void zaL(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.zat;
+        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);
+    }
+
+    public static GoogleApiManager zal() {
+        GoogleApiManager googleApiManager;
+        synchronized (zac) {
+            Preconditions.checkNotNull(zad, "Must guarantee manager is non-null before using getInstance");
+            googleApiManager = zad;
+        }
+        return googleApiManager;
+    }
+
+    public static GoogleApiManager zam(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
+    public final boolean handleMessage(Message message) {
+        ApiKey apiKey;
+        ApiKey apiKey2;
+        ApiKey apiKey3;
+        ApiKey apiKey4;
+        int i = message.what;
+        zabq zabqVar = null;
+        switch (i) {
+            case 1:
+                this.zag = true == ((Boolean) message.obj).booleanValue() ? 10000L : 300000L;
+                this.zat.removeMessages(12);
+                for (ApiKey apiKey5 : this.zap.keySet()) {
+                    Handler handler = this.zat;
+                    handler.sendMessageDelayed(handler.obtainMessage(12, apiKey5), this.zag);
+                }
+                return true;
+            case 2:
+                zal zalVar = (zal) message.obj;
+                Iterator it = zalVar.zab().iterator();
+                while (true) {
+                    if (it.hasNext()) {
+                        ApiKey apiKey6 = (ApiKey) it.next();
+                        zabq zabqVar2 = (zabq) this.zap.get(apiKey6);
+                        if (zabqVar2 == null) {
+                            zalVar.zac(apiKey6, new ConnectionResult(13), null);
+                        } else if (zabqVar2.zay()) {
+                            zalVar.zac(apiKey6, ConnectionResult.RESULT_SUCCESS, zabqVar2.zaf().getEndpointPackageName());
+                        } else {
+                            ConnectionResult zad2 = zabqVar2.zad();
+                            if (zad2 != null) {
+                                zalVar.zac(apiKey6, zad2, null);
+                            } else {
+                                zabqVar2.zat(zalVar);
+                                zabqVar2.zao();
+                            }
+                        }
+                    }
+                }
+                return true;
+            case 3:
+                for (zabq zabqVar3 : this.zap.values()) {
+                    zabqVar3.zan();
+                    zabqVar3.zao();
+                }
+                return true;
+            case 4:
+            case 8:
+            case 13:
+                zach zachVar = (zach) message.obj;
+                zabq zabqVar4 = (zabq) this.zap.get(zachVar.zac.getApiKey());
+                if (zabqVar4 == null) {
+                    zabqVar4 = zaI(zachVar.zac);
+                }
+                if (!zabqVar4.zaz() || this.zao.get() == zachVar.zab) {
+                    zabqVar4.zap(zachVar.zaa);
+                } else {
+                    zachVar.zaa.zad(zaa);
+                    zabqVar4.zav();
+                }
+                return true;
+            case 5:
+                int i4 = message.arg1;
+                ConnectionResult connectionResult = (ConnectionResult) message.obj;
+                Iterator it2 = this.zap.values().iterator();
+                while (true) {
+                    if (it2.hasNext()) {
+                        zabq zabqVar5 = (zabq) it2.next();
+                        if (zabqVar5.zab() == i4) {
+                            zabqVar = zabqVar5;
+                        }
+                    }
+                }
+                if (zabqVar == null) {
+                    Log.wtf("GoogleApiManager", w.t(i4, "Could not find API instance ", " while trying to fail enqueued calls.").toString(), new Exception());
+                } else if (connectionResult.getErrorCode() == 13) {
+                    zabq.zai(zabqVar, new Status(17, "Error resolution was canceled by the user, original error message: " + this.zal.getErrorString(connectionResult.getErrorCode()) + ": " + connectionResult.getErrorMessage()));
+                } else {
+                    zabq.zai(zabqVar, zaH(zabq.zag(zabqVar), connectionResult));
+                }
+                return true;
+            case 6:
+                if (this.zak.getApplicationContext() instanceof Application) {
+                    BackgroundDetector.initialize((Application) this.zak.getApplicationContext());
+                    BackgroundDetector.getInstance().addListener(new zabl(this));
+                    if (!BackgroundDetector.getInstance().readCurrentStateIfPossible(true)) {
+                        this.zag = 300000L;
+                    }
+                }
+                return true;
+            case 7:
+                zaI((GoogleApi) message.obj);
+                return true;
+            case 9:
+                if (this.zap.containsKey(message.obj)) {
+                    ((zabq) this.zap.get(message.obj)).zau();
+                }
+                return true;
+            case 10:
+                Iterator it3 = this.zas.iterator();
+                while (it3.hasNext()) {
+                    zabq zabqVar6 = (zabq) this.zap.remove((ApiKey) it3.next());
+                    if (zabqVar6 != null) {
+                        zabqVar6.zav();
+                    }
+                }
+                this.zas.clear();
+                return true;
+            case 11:
+                if (this.zap.containsKey(message.obj)) {
+                    ((zabq) this.zap.get(message.obj)).zaw();
+                }
+                return true;
+            case 12:
+                if (this.zap.containsKey(message.obj)) {
+                    ((zabq) this.zap.get(message.obj)).zaA();
+                }
+                return true;
+            case 14:
+                zaaf zaafVar = (zaaf) message.obj;
+                ApiKey zaa2 = zaafVar.zaa();
+                if (this.zap.containsKey(zaa2)) {
+                    zaafVar.zab().setResult(Boolean.valueOf(zabq.zax((zabq) this.zap.get(zaa2), false)));
+                } else {
+                    zaafVar.zab().setResult(Boolean.FALSE);
+                }
+                return true;
+            case 15:
+                zabs zabsVar = (zabs) message.obj;
+                Map map = this.zap;
+                apiKey = zabsVar.zaa;
+                if (map.containsKey(apiKey)) {
+                    Map map2 = this.zap;
+                    apiKey2 = zabsVar.zaa;
+                    zabq.zal((zabq) map2.get(apiKey2), zabsVar);
+                }
+                return true;
+            case 16:
+                zabs zabsVar2 = (zabs) message.obj;
+                Map map3 = this.zap;
+                apiKey3 = zabsVar2.zaa;
+                if (map3.containsKey(apiKey3)) {
+                    Map map4 = this.zap;
+                    apiKey4 = zabsVar2.zaa;
+                    zabq.zam((zabq) map4.get(apiKey4), zabsVar2);
+                }
+                return true;
+            case 17:
+                zaK();
+                return true;
+            case 18:
+                zace zaceVar = (zace) message.obj;
+                if (zaceVar.zac == 0) {
+                    zaJ().log(new TelemetryData(zaceVar.zab, Arrays.asList(zaceVar.zaa)));
+                } else {
+                    TelemetryData telemetryData = this.zai;
+                    if (telemetryData != null) {
+                        List zab2 = telemetryData.zab();
+                        if (telemetryData.zaa() != zaceVar.zab || (zab2 != null && zab2.size() >= zaceVar.zad)) {
+                            this.zat.removeMessages(17);
+                            zaK();
+                        } else {
+                            this.zai.zac(zaceVar.zaa);
+                        }
+                    }
+                    if (this.zai == null) {
+                        ArrayList arrayList = new ArrayList();
+                        arrayList.add(zaceVar.zaa);
+                        this.zai = new TelemetryData(zaceVar.zab, arrayList);
+                        Handler handler2 = this.zat;
+                        handler2.sendMessageDelayed(handler2.obtainMessage(17), zaceVar.zac);
+                    }
+                }
+                return true;
+            case 19:
+                this.zah = false;
+                return true;
+            default:
+                Log.w("GoogleApiManager", "Unknown message id: " + i);
+                return false;
+        }
+    }
+
+    public final void zaA() {
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(3));
+    }
+
+    public final void zaB(GoogleApi googleApi) {
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(7, googleApi));
+    }
+
+    public final void zaC(zaae zaaeVar) {
+        synchronized (zac) {
+            try {
+                if (this.zaq != zaaeVar) {
+                    this.zaq = zaaeVar;
+                    this.zar.clear();
+                }
+                this.zar.addAll(zaaeVar.zaa());
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void zaD(zaae zaaeVar) {
+        synchronized (zac) {
+            try {
+                if (this.zaq == zaaeVar) {
+                    this.zaq = null;
+                    this.zar.clear();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final boolean zaF() {
+        if (this.zah) {
+            return false;
+        }
+        RootTelemetryConfiguration config = RootTelemetryConfigManager.getInstance().getConfig();
+        if (config != null && !config.getMethodInvocationTelemetryEnabled()) {
+            return false;
+        }
+        int zaa2 = this.zam.zaa(this.zak, 203400000);
+        return zaa2 == -1 || zaa2 == 0;
+    }
+
+    public final boolean zaG(ConnectionResult connectionResult, int i) {
+        return this.zal.zah(this.zak, connectionResult, i);
+    }
+
+    public final int zaa() {
+        return this.zan.getAndIncrement();
+    }
+
+    public final zabq zak(ApiKey apiKey) {
+        return (zabq) this.zap.get(apiKey);
+    }
+
+    public final Task zao(Iterable iterable) {
+        zal zalVar = new zal(iterable);
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(2, zalVar));
+        return zalVar.zaa();
+    }
+
+    public final Task zap(GoogleApi googleApi) {
+        zaaf zaafVar = new zaaf(googleApi.getApiKey());
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(14, zaafVar));
+        return zaafVar.zab().getTask();
+    }
+
+    public final Task zaq(GoogleApi googleApi, RegisterListenerMethod registerListenerMethod, UnregisterListenerMethod unregisterListenerMethod, Runnable runnable) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        zaL(taskCompletionSource, registerListenerMethod.zaa(), googleApi);
+        zaf zafVar = new zaf(new zaci(registerListenerMethod, unregisterListenerMethod, runnable), taskCompletionSource);
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(8, new zach(zafVar, this.zao.get(), googleApi)));
+        return taskCompletionSource.getTask();
+    }
+
+    public final Task zar(GoogleApi googleApi, ListenerHolder.ListenerKey listenerKey, int i) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        zaL(taskCompletionSource, i, googleApi);
+        zah zahVar = new zah(listenerKey, taskCompletionSource);
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(13, new zach(zahVar, this.zao.get(), googleApi)));
+        return taskCompletionSource.getTask();
+    }
+
+    public final void zaw(GoogleApi googleApi, int i, BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        zae zaeVar = new zae(i, apiMethodImpl);
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(4, new zach(zaeVar, this.zao.get(), googleApi)));
+    }
+
+    public final void zax(GoogleApi googleApi, int i, TaskApiCall taskApiCall, TaskCompletionSource taskCompletionSource, StatusExceptionMapper statusExceptionMapper) {
+        zaL(taskCompletionSource, taskApiCall.zaa(), googleApi);
+        zag zagVar = new zag(i, taskApiCall, taskCompletionSource, statusExceptionMapper);
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(4, new zach(zagVar, this.zao.get(), googleApi)));
+    }
+
+    public final void zay(MethodInvocation methodInvocation, int i, long j4, int i4) {
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(18, new zace(methodInvocation, i, j4, i4)));
+    }
+
+    public final void zaz(ConnectionResult connectionResult, int i) {
+        if (zaG(connectionResult, i)) {
+            return;
+        }
+        Handler handler = this.zat;
+        handler.sendMessage(handler.obtainMessage(5, i, 0, connectionResult));
+    }
+}

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

@@ -0,0 +1,142 @@
+package com.google.android.gms.common.api.internal;
+
+import C.w;
+import android.content.Context;
+import android.content.res.Resources;
+import android.text.TextUtils;
+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.zzag;
+import com.google.android.gms.common.util.VisibleForTesting;
+
+@KeepForSdk
+@Deprecated
+/* loaded from: classes3.dex */
+public final class GoogleServices {
+    private static final Object zza = new Object();
+    private static GoogleServices zzb;
+    private final String zzc;
+    private final Status zzd;
+    private final boolean zze;
+    private final boolean zzf;
+
+    @VisibleForTesting
+    @KeepForSdk
+    public GoogleServices(String str, boolean z3) {
+        this.zzc = str;
+        this.zzd = Status.RESULT_SUCCESS;
+        this.zze = z3;
+        this.zzf = !z3;
+    }
+
+    @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 + ".");
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return googleServices;
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    public static void clearInstanceForTest() {
+        synchronized (zza) {
+            zzb = null;
+        }
+    }
+
+    @KeepForSdk
+    public static String getGoogleAppId() {
+        return checkInitialized("getGoogleAppId").zzc;
+    }
+
+    @KeepForSdk
+    public static Status initialize(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;
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    public Status checkGoogleAppId(String str) {
+        String str2 = this.zzc;
+        return (str2 == null || str2.equals(str)) ? Status.RESULT_SUCCESS : new Status(10, w.o("Initialize was called with two different Google App IDs.  Only the first app ID will be used: '", this.zzc, "'."));
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    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 z3 = integer == 0;
+            r2 = integer != 0;
+            this.zzf = z3;
+        } else {
+            this.zzf = false;
+        }
+        this.zze = r2;
+        String zzb2 = zzag.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
+    public static Status initialize(Context context, String str, boolean z3) {
+        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, z3);
+                zzb = googleServices2;
+                return googleServices2.zzd;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+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 com.google.android.gms.common.api.Status;
+
+/* loaded from: classes3.dex */
+public interface IStatusCallback extends IInterface {
+
+    /* loaded from: classes3.dex */
+    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");
+        }
+
+        public static IStatusCallback asInterface(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, Parcel parcel, Parcel parcel2, int i4) 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(Status status) throws RemoteException;
+}

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

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

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

@@ -0,0 +1,89 @@
+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 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: classes3.dex */
+public class LifecycleCallback {
+
+    @KeepForSdk
+    protected final LifecycleFragment mLifecycleFragment;
+
+    @KeepForSdk
+    public LifecycleCallback(LifecycleFragment lifecycleFragment) {
+        this.mLifecycleFragment = lifecycleFragment;
+    }
+
+    @Keep
+    private static LifecycleFragment getChimeraLifecycleFragmentImpl(LifecycleActivity lifecycleActivity) {
+        throw new IllegalStateException("Method not available in SDK.");
+    }
+
+    @KeepForSdk
+    public static LifecycleFragment getFragment(Activity activity) {
+        return getFragment(new LifecycleActivity(activity));
+    }
+
+    @KeepForSdk
+    public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+    }
+
+    @KeepForSdk
+    public Activity getActivity() {
+        Activity lifecycleActivity = this.mLifecycleFragment.getLifecycleActivity();
+        Preconditions.checkNotNull(lifecycleActivity);
+        return lifecycleActivity;
+    }
+
+    @KeepForSdk
+    public void onActivityResult(int i, int i4, Intent intent) {
+    }
+
+    @KeepForSdk
+    public void onCreate(Bundle bundle) {
+    }
+
+    @KeepForSdk
+    public void onDestroy() {
+    }
+
+    @KeepForSdk
+    public void onResume() {
+    }
+
+    @KeepForSdk
+    public void onSaveInstanceState(Bundle bundle) {
+    }
+
+    @KeepForSdk
+    public void onStart() {
+    }
+
+    @KeepForSdk
+    public void onStop() {
+    }
+
+    @KeepForSdk
+    public static LifecycleFragment getFragment(ContextWrapper contextWrapper) {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public static LifecycleFragment getFragment(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.");
+    }
+}

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

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

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

@@ -0,0 +1,116 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+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: classes3.dex */
+public final class ListenerHolder<L> {
+    private final Executor zaa;
+    private volatile Object zab;
+    private volatile ListenerKey zac;
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public static final class ListenerKey<L> {
+        private final Object zaa;
+        private final String zab;
+
+        @KeepForSdk
+        public ListenerKey(L l4, String str) {
+            this.zaa = l4;
+            this.zab = str;
+        }
+
+        @KeepForSdk
+        public boolean equals(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 this.zab.hashCode() + (System.identityHashCode(this.zaa) * 31);
+        }
+
+        @KeepForSdk
+        public String toIdString() {
+            return this.zab + "@" + System.identityHashCode(this.zaa);
+        }
+    }
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    public interface Notifier<L> {
+        @KeepForSdk
+        void notifyListener(L l4);
+
+        @KeepForSdk
+        void onNotifyListenerFailed();
+    }
+
+    @KeepForSdk
+    public ListenerHolder(Looper looper, L l4, String str) {
+        this.zaa = new HandlerExecutor(looper);
+        this.zab = Preconditions.checkNotNull(l4, "Listener must not be null");
+        this.zac = new ListenerKey(l4, Preconditions.checkNotEmpty(str));
+    }
+
+    @KeepForSdk
+    public void clear() {
+        this.zab = null;
+        this.zac = null;
+    }
+
+    @KeepForSdk
+    public ListenerKey<L> getListenerKey() {
+        return this.zac;
+    }
+
+    @KeepForSdk
+    public boolean hasListener() {
+        return this.zab != null;
+    }
+
+    @KeepForSdk
+    public void notifyListener(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 e4) {
+            notifier.onNotifyListenerFailed();
+            throw e4;
+        }
+    }
+
+    @KeepForSdk
+    public ListenerHolder(Executor executor, L l4, String str) {
+        this.zaa = (Executor) Preconditions.checkNotNull(executor, "Executor must not be null");
+        this.zab = Preconditions.checkNotNull(l4, "Listener must not be null");
+        this.zac = new ListenerKey(l4, Preconditions.checkNotEmpty(str));
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+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: classes3.dex */
+public class ListenerHolders {
+    private final Set zaa = Collections.newSetFromMap(new WeakHashMap());
+
+    @KeepForSdk
+    public static <L> ListenerHolder<L> createListenerHolder(L l4, Looper looper, String str) {
+        Preconditions.checkNotNull(l4, "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, l4, str);
+    }
+
+    @KeepForSdk
+    public static <L> ListenerHolder.ListenerKey<L> createListenerKey(L l4, String str) {
+        Preconditions.checkNotNull(l4, "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<>(l4, str);
+    }
+
+    public final ListenerHolder zaa(Object obj, Looper looper, String str) {
+        ListenerHolder createListenerHolder = createListenerHolder(obj, looper, "NO_TYPE");
+        this.zaa.add(createListenerHolder);
+        return createListenerHolder;
+    }
+
+    public final void zab() {
+        Iterator it = this.zaa.iterator();
+        while (it.hasNext()) {
+            ((ListenerHolder) it.next()).clear();
+        }
+        this.zaa.clear();
+    }
+
+    @KeepForSdk
+    public static <L> ListenerHolder<L> createListenerHolder(L l4, Executor executor, String str) {
+        Preconditions.checkNotNull(l4, "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, l4, str);
+    }
+}

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

@@ -0,0 +1,282 @@
+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 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: classes3.dex */
+public final class NonGmsServiceBrokerClient implements Api.Client, ServiceConnection {
+    private static final String zaa = "NonGmsServiceBrokerClient";
+    private final String zab;
+    private final String zac;
+    private final ComponentName zad;
+    private final Context zae;
+    private final ConnectionCallbacks zaf;
+    private final Handler zag;
+    private final OnConnectionFailedListener zah;
+    private IBinder zai;
+    private boolean zaj;
+    private String zak;
+    private String zal;
+
+    @KeepForSdk
+    public NonGmsServiceBrokerClient(Context context, Looper looper, ComponentName componentName, ConnectionCallbacks connectionCallbacks, OnConnectionFailedListener onConnectionFailedListener) {
+        this(context, looper, null, null, componentName, connectionCallbacks, onConnectionFailedListener);
+    }
+
+    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
+    public final void connect(BaseGmsClient.ConnectionProgressReportCallbacks connectionProgressReportCallbacks) {
+        zad();
+        String.valueOf(this.zai);
+        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) {
+                this.zai = null;
+                this.zah.onConnectionFailed(new ConnectionResult(16));
+            }
+            String.valueOf(this.zai);
+        } catch (SecurityException e4) {
+            this.zaj = false;
+            this.zai = null;
+            throw e4;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final void disconnect() {
+        zad();
+        String.valueOf(this.zai);
+        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(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final Feature[] getAvailableFeatures() {
+        return new Feature[0];
+    }
+
+    @KeepForSdk
+    public IBinder getBinder() {
+        zad();
+        return this.zai;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    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
+    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(IAccountAccessor iAccountAccessor, Set<Scope> set) {
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final Feature[] getRequiredFeatures() {
+        return new Feature[0];
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final Set<Scope> getScopesForConnectionlessNonSignIn() {
+        return Collections.EMPTY_SET;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final IBinder getServiceBrokerBinder() {
+        return null;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final Intent getSignInIntent() {
+        return new Intent();
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final boolean isConnected() {
+        zad();
+        return this.zai != null;
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final boolean isConnecting() {
+        zad();
+        return this.zaj;
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceConnected(ComponentName componentName, 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(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(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;
+        String.valueOf(iBinder);
+        this.zaf.onConnected(new Bundle());
+    }
+
+    public final /* synthetic */ void zab() {
+        this.zaj = false;
+        this.zai = null;
+        this.zaf.onConnectionSuspended(1);
+    }
+
+    public final void zac(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, java.lang.String r4, java.lang.String r5, 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 r1 = new java.lang.AssertionError
+            java.lang.String r2 = "Must specify either package or component, but not both"
+            r1.<init>(r2)
+            throw r1
+        */
+        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");
+    }
+
+    @KeepForSdk
+    public NonGmsServiceBrokerClient(Context context, Looper looper, String str, String str2, ConnectionCallbacks connectionCallbacks, OnConnectionFailedListener onConnectionFailedListener) {
+        this(context, looper, str, str2, null, connectionCallbacks, onConnectionFailedListener);
+    }
+
+    @Override // com.google.android.gms.common.api.Api.Client
+    public final void disconnect(String str) {
+        zad();
+        this.zak = str;
+        disconnect();
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public interface OnConnectionFailedListener {
+    @ShowFirstParty
+    @KeepForSdk
+    void onConnectionFailed(ConnectionResult connectionResult);
+}

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

@@ -0,0 +1,73 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public final class OptionalPendingResultImpl<R extends Result> extends OptionalPendingResult<R> {
+    private final BasePendingResult zaa;
+
+    public OptionalPendingResultImpl(PendingResult pendingResult) {
+        this.zaa = (BasePendingResult) pendingResult;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void addStatusListener(PendingResult.StatusListener statusListener) {
+        this.zaa.addStatusListener(statusListener);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    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
+    public final R get() {
+        if (!this.zaa.isReady()) {
+            throw new IllegalStateException("Result is not available. Check that isDone() returns true before calling get().");
+        }
+        return (R) this.zaa.await(0L, TimeUnit.MILLISECONDS);
+    }
+
+    @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(ResultCallback<? super R> resultCallback) {
+        this.zaa.setResultCallback(resultCallback);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final <S extends Result> TransformedResult<S> then(ResultTransform<? super R, ? extends S> resultTransform) {
+        return this.zaa.then(resultTransform);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final R await(long j4, TimeUnit timeUnit) {
+        return (R) this.zaa.await(j4, timeUnit);
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(ResultCallback<? super R> resultCallback, long j4, TimeUnit timeUnit) {
+        this.zaa.setResultCallback(resultCallback, j4, timeUnit);
+    }
+}

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

@@ -0,0 +1,53 @@
+package com.google.android.gms.common.api.internal;
+
+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 java.util.concurrent.TimeUnit;
+
+@KeepForSdk
+/* loaded from: classes3.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(PendingResult.StatusListener statusListener) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final B await() {
+        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(ResultCallback<? super B> resultCallback) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final <S extends Result> TransformedResult<S> then(ResultTransform<? super B, ? extends S> resultTransform) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final B await(long j4, TimeUnit timeUnit) {
+        throw null;
+    }
+
+    @Override // com.google.android.gms.common.api.PendingResult
+    public final void setResultCallback(ResultCallback<? super B> resultCallback, long j4, TimeUnit timeUnit) {
+        throw null;
+    }
+}

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

@@ -0,0 +1,62 @@
+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.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: classes3.dex */
+public abstract class RegisterListenerMethod<A extends Api.AnyClient, L> {
+    private final ListenerHolder zaa;
+    private final Feature[] zab;
+    private final boolean zac;
+    private final int zad;
+
+    @KeepForSdk
+    public RegisterListenerMethod(ListenerHolder<L> listenerHolder, Feature[] featureArr, boolean z3, int i) {
+        this.zaa = listenerHolder;
+        this.zab = featureArr;
+        this.zac = z3;
+        this.zad = i;
+    }
+
+    @KeepForSdk
+    public void clearListener() {
+        this.zaa.clear();
+    }
+
+    @KeepForSdk
+    public ListenerHolder.ListenerKey<L> getListenerKey() {
+        return this.zaa.getListenerKey();
+    }
+
+    @KeepForSdk
+    public Feature[] getRequiredFeatures() {
+        return this.zab;
+    }
+
+    @KeepForSdk
+    public abstract void registerListener(A a2, TaskCompletionSource<Void> taskCompletionSource) throws RemoteException;
+
+    public final int zaa() {
+        return this.zad;
+    }
+
+    public final boolean zab() {
+        return this.zac;
+    }
+
+    @KeepForSdk
+    public RegisterListenerMethod(ListenerHolder<L> listenerHolder) {
+        this(listenerHolder, null, false, 0);
+    }
+
+    @KeepForSdk
+    public RegisterListenerMethod(ListenerHolder<L> listenerHolder, Feature[] featureArr, boolean z3) {
+        this(listenerHolder, featureArr, z3, 0);
+    }
+}

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

@@ -0,0 +1,98 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public class RegistrationMethods<A extends Api.AnyClient, L> {
+
+    @KeepForSdk
+    public final RegisterListenerMethod<A, L> register;
+    public final UnregisterListenerMethod zaa;
+    public final Runnable zab;
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    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() {
+        }
+
+        @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);
+        }
+
+        @KeepForSdk
+        public Builder<A, L> onConnectionSuspended(Runnable runnable) {
+            this.zac = runnable;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, L> register(RemoteCall<A, TaskCompletionSource<Void>> remoteCall) {
+            this.zaa = remoteCall;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, L> setAutoResolveMissingFeatures(boolean z3) {
+            this.zaf = z3;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, L> setFeatures(Feature... featureArr) {
+            this.zae = featureArr;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, L> setMethodKey(int i) {
+            this.zag = i;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, L> unregister(RemoteCall<A, TaskCompletionSource<Boolean>> remoteCall) {
+            this.zab = remoteCall;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, L> withHolder(ListenerHolder<L> listenerHolder) {
+            this.zad = listenerHolder;
+            return this;
+        }
+
+        public /* synthetic */ Builder(zacm zacmVar) {
+        }
+    }
+
+    public /* synthetic */ RegistrationMethods(RegisterListenerMethod registerListenerMethod, UnregisterListenerMethod unregisterListenerMethod, Runnable runnable, zacn zacnVar) {
+        this.register = registerListenerMethod;
+        this.zaa = unregisterListenerMethod;
+        this.zab = runnable;
+    }
+
+    @KeepForSdk
+    public static <A extends Api.AnyClient, L> Builder<A, L> builder() {
+        return new Builder<>(null);
+    }
+}

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

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

apk_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: classes3.dex */
+public interface SignInConnectionListener {
+    @KeepForSdk
+    void onComplete();
+}

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

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.dex */
+public class StatusCallback extends IStatusCallback.Stub {
+
+    @KeepForSdk
+    private final BaseImplementation.ResultHolder<Status> mResultHolder;
+
+    @KeepForSdk
+    public StatusCallback(BaseImplementation.ResultHolder<Status> resultHolder) {
+        this.mResultHolder = resultHolder;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.IStatusCallback
+    @KeepForSdk
+    public void onResult(Status status) {
+        this.mResultHolder.setResult(status);
+    }
+}

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

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

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

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+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: classes3.dex */
+public class StatusPendingResult extends BasePendingResult<Status> {
+    @Deprecated
+    public StatusPendingResult(Looper looper) {
+        super(looper);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.BasePendingResult
+    public final /* bridge */ /* synthetic */ Status createFailedResult(Status status) {
+        return status;
+    }
+
+    @KeepForSdk
+    public StatusPendingResult(GoogleApiClient googleApiClient) {
+        super(googleApiClient);
+    }
+}

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

@@ -0,0 +1,115 @@
+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.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: classes3.dex */
+public abstract class TaskApiCall<A extends Api.AnyClient, ResultT> {
+    private final Feature[] zaa;
+    private final boolean zab;
+    private final int zac;
+
+    @KeepForSdk
+    /* loaded from: classes3.dex */
+    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() {
+        }
+
+        @KeepForSdk
+        public TaskApiCall<A, ResultT> build() {
+            Preconditions.checkArgument(this.zaa != null, "execute parameter required");
+            return new zacv(this, this.zac, this.zab, this.zad);
+        }
+
+        @KeepForSdk
+        @Deprecated
+        public Builder<A, ResultT> execute(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;
+        }
+
+        @KeepForSdk
+        public Builder<A, ResultT> run(RemoteCall<A, TaskCompletionSource<ResultT>> remoteCall) {
+            this.zaa = remoteCall;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, ResultT> setAutoResolveMissingFeatures(boolean z3) {
+            this.zab = z3;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, ResultT> setFeatures(Feature... featureArr) {
+            this.zac = featureArr;
+            return this;
+        }
+
+        @KeepForSdk
+        public Builder<A, ResultT> setMethodKey(int i) {
+            this.zad = i;
+            return this;
+        }
+
+        public /* synthetic */ Builder(zacw zacwVar) {
+        }
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public TaskApiCall() {
+        this.zaa = null;
+        this.zab = false;
+        this.zac = 0;
+    }
+
+    @KeepForSdk
+    public static <A extends Api.AnyClient, ResultT> Builder<A, ResultT> builder() {
+        return new Builder<>(null);
+    }
+
+    @KeepForSdk
+    public abstract void doExecute(A a2, TaskCompletionSource<ResultT> taskCompletionSource) throws RemoteException;
+
+    @KeepForSdk
+    public boolean shouldAutoResolveMissingFeatures() {
+        return this.zab;
+    }
+
+    public final int zaa() {
+        return this.zac;
+    }
+
+    public final Feature[] zab() {
+        return this.zaa;
+    }
+
+    @KeepForSdk
+    public TaskApiCall(Feature[] featureArr, boolean z3, int i) {
+        this.zaa = featureArr;
+        boolean z4 = false;
+        if (featureArr != null && z3) {
+            z4 = true;
+        }
+        this.zab = z4;
+        this.zac = i;
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.api.internal;
+
+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;
+
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class TaskUtil {
+    @KeepForSdk
+    public static void setResultOrApiException(Status status, TaskCompletionSource<Void> taskCompletionSource) {
+        setResultOrApiException(status, null, taskCompletionSource);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static Task<Void> toVoidTaskThatFailsOnFalse(Task<Boolean> task) {
+        return task.continueWith(new zacx());
+    }
+
+    @KeepForSdk
+    public static <ResultT> boolean trySetResultOrApiException(Status status, ResultT resultt, TaskCompletionSource<ResultT> taskCompletionSource) {
+        return status.isSuccess() ? taskCompletionSource.trySetResult(resultt) : taskCompletionSource.trySetException(ApiExceptionUtil.fromStatus(status));
+    }
+
+    @KeepForSdk
+    public static <ResultT> void setResultOrApiException(Status status, ResultT resultt, TaskCompletionSource<ResultT> taskCompletionSource) {
+        if (status.isSuccess()) {
+            taskCompletionSource.setResult(resultt);
+        } else {
+            taskCompletionSource.setException(ApiExceptionUtil.fromStatus(status));
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.RemoteException;
+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: classes3.dex */
+public abstract class UnregisterListenerMethod<A extends Api.AnyClient, L> {
+    private final ListenerHolder.ListenerKey zaa;
+
+    @KeepForSdk
+    public UnregisterListenerMethod(ListenerHolder.ListenerKey<L> listenerKey) {
+        this.zaa = listenerKey;
+    }
+
+    @KeepForSdk
+    public ListenerHolder.ListenerKey<L> getListenerKey() {
+        return this.zaa;
+    }
+
+    @KeepForSdk
+    public abstract void unregisterListener(A a2, TaskCompletionSource<Boolean> taskCompletionSource) throws RemoteException;
+}

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

@@ -0,0 +1,51 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes3.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
+    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();
+        }
+    }
+}

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

@@ -0,0 +1,395 @@
+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 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;
+import s.j;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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;
+    private final Api.Client zah;
+    private Bundle zai;
+    private final Lock zam;
+    private final Set zag = Collections.newSetFromMap(new WeakHashMap());
+    private ConnectionResult zaj = null;
+    private ConnectionResult zak = null;
+    private boolean zal = false;
+    private int zan = 0;
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r15v1, types: [java.util.Map, s.j] */
+    private zaaa(Context context, zabe zabeVar, Lock lock, Looper looper, GoogleApiAvailabilityLight googleApiAvailabilityLight, Map map, Map map2, ClientSettings clientSettings, Api.AbstractClientBuilder abstractClientBuilder, 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, 0 == true ? 1 : 0));
+        ?? jVar = new j(0);
+        Iterator it = map2.keySet().iterator();
+        while (it.hasNext()) {
+            jVar.put((Api.AnyClientKey) it.next(), this.zad);
+        }
+        Iterator it2 = map.keySet().iterator();
+        while (it2.hasNext()) {
+            jVar.put((Api.AnyClientKey) it2.next(), this.zae);
+        }
+        this.zaf = Collections.unmodifiableMap(jVar);
+    }
+
+    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;
+    }
+
+    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(ConnectionResult connectionResult) {
+        return connectionResult != null && connectionResult.isSuccess();
+    }
+
+    /* JADX WARN: Type inference failed for: r13v0, types: [java.util.Map, s.j] */
+    /* JADX WARN: Type inference failed for: r14v0, types: [java.util.Map, s.j] */
+    /* JADX WARN: Type inference failed for: r6v0, types: [java.util.Map, s.j] */
+    /* JADX WARN: Type inference failed for: r7v0, types: [java.util.Map, s.j] */
+    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) {
+        ?? jVar = new j(0);
+        ?? jVar2 = new j(0);
+        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()) {
+                jVar.put((Api.AnyClientKey) entry.getKey(), client2);
+            } else {
+                jVar2.put((Api.AnyClientKey) entry.getKey(), client2);
+            }
+        }
+        Preconditions.checkState(!jVar.isEmpty(), "CompositeGoogleApiClient should not be used without any APIs that require sign-in.");
+        ?? jVar3 = new j(0);
+        ?? jVar4 = new j(0);
+        for (Api api : map2.keySet()) {
+            Api.AnyClientKey zab = api.zab();
+            if (jVar.containsKey(zab)) {
+                jVar3.put(api, (Boolean) map2.get(api));
+            } else {
+                if (!jVar2.containsKey(zab)) {
+                    throw new IllegalStateException("Each API in the isOptionalMap must have a corresponding client in the clients map.");
+                }
+                jVar4.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 (jVar3.containsKey(zatVar.zaa)) {
+                arrayList2.add(zatVar);
+            } else {
+                if (!jVar4.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, jVar, jVar2, clientSettings, abstractClientBuilder, client, arrayList2, arrayList3, jVar3, jVar4);
+    }
+
+    public static /* bridge */ /* synthetic */ void zan(zaaa zaaaVar, int i, boolean z3) {
+        zaaaVar.zab.zac(i, z3);
+        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;
+    }
+
+    private final PendingIntent zaz() {
+        if (this.zah == null) {
+            return null;
+        }
+        return PendingIntent.getActivity(this.zaa, System.identityHashCode(this.zab), this.zah.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 j4, TimeUnit timeUnit) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zaca
+    public final ConnectionResult zad(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(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(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, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        printWriter.append((CharSequence) str).append("authClient").println(":");
+        this.zae.zas(String.valueOf(str).concat("  "), fileDescriptor, printWriter, strArr);
+        printWriter.append((CharSequence) str).append("anonClient").println(":");
+        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 r3 = r3.zam
+            r3.unlock()
+            return r1
+        L2b:
+            java.util.concurrent.locks.Lock r3 = r3.zam
+            r3.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 {
+            if (!zax()) {
+                if (zaw()) {
+                }
+                this.zam.unlock();
+                return false;
+            }
+            if (!this.zae.zaw()) {
+                this.zag.add(signInConnectionListener);
+                if (this.zan == 0) {
+                    this.zan = 1;
+                }
+                this.zak = null;
+                this.zae.zaq();
+                this.zam.unlock();
+                return true;
+            }
+            this.zam.unlock();
+            return false;
+        } catch (Throwable th) {
+            this.zam.unlock();
+            throw th;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+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;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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);
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+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;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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(Task task) {
+        Map map;
+        map = this.zab.zab;
+        map.remove(this.zaa);
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.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 z3, 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 (z3 || ((Boolean) entry.getValue()).booleanValue()) {
+                ((BasePendingResult) entry.getKey()).forceFailureUnlessReady(status);
+            }
+        }
+        for (Map.Entry entry2 : hashMap2.entrySet()) {
+            if (z3 || ((Boolean) entry2.getValue()).booleanValue()) {
+                ((TaskCompletionSource) entry2.getKey()).trySetException(new ApiException(status));
+            }
+        }
+    }
+
+    public final void zac(BasePendingResult basePendingResult, boolean z3) {
+        this.zaa.put(basePendingResult, Boolean.valueOf(z3));
+        basePendingResult.addStatusListener(new zaab(this, basePendingResult));
+    }
+
+    public final void zad(TaskCompletionSource taskCompletionSource, boolean z3) {
+        this.zab.put(taskCompletionSource, Boolean.valueOf(z3));
+        taskCompletionSource.getTask().addOnCompleteListener(new zaac(this, taskCompletionSource));
+    }
+
+    public final void zae(int i, 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;
+    }
+}

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

@@ -0,0 +1,72 @@
+package com.google.android.gms.common.api.internal;
+
+import android.app.Activity;
+import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.util.VisibleForTesting;
+import s.f;
+
+/* loaded from: classes3.dex */
+public final class zaae extends zap {
+    private final f zad;
+    private final GoogleApiManager zae;
+
+    @VisibleForTesting
+    public zaae(LifecycleFragment lifecycleFragment, GoogleApiManager googleApiManager, GoogleApiAvailability googleApiAvailability) {
+        super(lifecycleFragment, googleApiAvailability);
+        this.zad = new f(0);
+        this.zae = googleApiManager;
+        this.mLifecycleFragment.addCallback("ConnectionlessLifecycleHelper", this);
+    }
+
+    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.zaC(zaaeVar);
+    }
+
+    private final void zae() {
+        if (this.zad.isEmpty()) {
+            return;
+        }
+        this.zae.zaC(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.zaD(this);
+    }
+
+    public final f zaa() {
+        return this.zad;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap
+    public final void zab(ConnectionResult connectionResult, int i) {
+        this.zae.zaz(connectionResult, i);
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zap
+    public final void zac() {
+        this.zae.zaA();
+    }
+}

apk_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: classes3.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;
+    }
+}

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

@@ -0,0 +1,109 @@
+package com.google.android.gms.common.api.internal;
+
+import androidx.fragment.app.P;
+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: classes3.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
+    public final ConnectionResult getConnectionResult(Api<?> api) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean hasConnectedApi(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(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnectionFailedListenerRegistered(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(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void registerConnectionFailedListener(GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void stopAutoManage(P p) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionCallbacks(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionFailedListener(GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final ConnectionResult blockingConnect(long j4, TimeUnit timeUnit) {
+        throw new UnsupportedOperationException(this.zaa);
+    }
+}

apk_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: classes3.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);
+    }
+}

apk_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: classes3.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);
+    }
+}

apk_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 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: classes3.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);
+                return apiMethodImpl;
+            }
+            apiMethodImpl.setFailedResult(new Status(17));
+            return apiMethodImpl;
+        } 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(Bundle bundle) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zah(ConnectionResult connectionResult, Api api, boolean z3) {
+    }
+
+    @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;
+    }
+}

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

@@ -0,0 +1,24 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import com.google.android.gms.common.GoogleApiAvailabilityLight;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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);
+    }
+}

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

@@ -0,0 +1,61 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+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: classes3.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 z3) {
+        this.zaa = new WeakReference(zaawVar);
+        this.zab = api;
+        this.zac = z3;
+    }
+
+    @Override // com.google.android.gms.common.internal.BaseGmsClient.ConnectionProgressReportCallbacks
+    public final void onReportServiceBinding(ConnectionResult connectionResult) {
+        zabi zabiVar;
+        Lock lock;
+        Lock lock2;
+        boolean zaG;
+        boolean zaH;
+        Lock lock3;
+        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();
+                }
+                lock3 = zaawVar.zab;
+            } else {
+                lock3 = zaawVar.zab;
+            }
+            lock3.unlock();
+        } catch (Throwable th) {
+            lock2 = zaawVar.zab;
+            lock2.unlock();
+            throw th;
+        }
+    }
+}

apk_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: classes3.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);
+    }
+}

apk_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: classes3.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));
+    }
+}

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

@@ -0,0 +1,103 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+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;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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
+    public final void zaa() {
+        GoogleApiAvailabilityLight googleApiAvailabilityLight;
+        Context context;
+        boolean z3;
+        Context context2;
+        zabi zabiVar;
+        com.google.android.gms.signin.zae zaeVar;
+        com.google.android.gms.signin.zae zaeVar2;
+        zabi zabiVar2;
+        Context context3;
+        boolean z4;
+        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()) {
+                z4 = ((zaal) this.zac.get(client)).zac;
+                if (!z4) {
+                    arrayList.add(client);
+                }
+            }
+            arrayList2.add(client);
+        }
+        int i = -1;
+        int i4 = 0;
+        if (!arrayList.isEmpty()) {
+            int size = arrayList.size();
+            while (i4 < size) {
+                Api.Client client2 = (Api.Client) arrayList.get(i4);
+                context = this.zaa.zac;
+                i = zalVar.zab(context, client2);
+                i4++;
+                if (i != 0) {
+                    break;
+                }
+            }
+        } else {
+            int size2 = arrayList2.size();
+            while (i4 < size2) {
+                Api.Client client3 = (Api.Client) arrayList2.get(i4);
+                context3 = this.zaa.zac;
+                i = zalVar.zab(context3, client3);
+                i4++;
+                if (i == 0) {
+                    break;
+                }
+            }
+        }
+        if (i != 0) {
+            ConnectionResult connectionResult = new ConnectionResult(i, null);
+            zaaw zaawVar = this.zaa;
+            zabiVar2 = zaawVar.zaa;
+            zabiVar2.zal(new zaam(this, zaawVar, connectionResult));
+            return;
+        }
+        zaaw zaawVar2 = this.zaa;
+        z3 = zaawVar2.zam;
+        if (z3) {
+            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);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.google.android.gms.common.api.internal;
+
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.internal.IAccountAccessor;
+import java.util.ArrayList;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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
+    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);
+        }
+    }
+}

apk_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: classes3.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);
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.google.android.gms.common.api.internal;
+
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes3.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
+    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));
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+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: classes3.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(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(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) {
+    }
+}

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

@@ -0,0 +1,39 @@
+package com.google.android.gms.common.api.internal;
+
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes3.dex */
+abstract class zaav implements Runnable {
+    final /* synthetic */ zaaw zab;
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Lock lock;
+        Lock lock2;
+        zabi zabiVar;
+        Lock lock3;
+        lock = this.zab.zab;
+        lock.lock();
+        try {
+            try {
+                if (Thread.interrupted()) {
+                    lock3 = this.zab.zab;
+                } else {
+                    zaa();
+                    lock3 = this.zab.zab;
+                }
+            } catch (RuntimeException e4) {
+                zabiVar = this.zab.zaa;
+                zabiVar.zam(e4);
+                lock3 = this.zab.zab;
+            }
+            lock3.unlock();
+        } catch (Throwable th) {
+            lock2 = this.zab.zab;
+            lock2.unlock();
+            throw th;
+        }
+    }
+
+    public abstract void zaa();
+}

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

@@ -0,0 +1,330 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Looper;
+import android.util.Log;
+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: classes3.dex */
+public final class zaaw implements zabf {
+    private final zabi zaa;
+    private final Lock zab;
+    private final Context zac;
+    private final GoogleApiAvailabilityLight zad;
+    private ConnectionResult zae;
+    private int zaf;
+    private int zah;
+    private com.google.android.gms.signin.zae zak;
+    private boolean zal;
+    private boolean zam;
+    private boolean zan;
+    private IAccountAccessor zao;
+    private boolean zap;
+    private boolean zaq;
+    private final ClientSettings zar;
+    private final Map zas;
+    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, ClientSettings clientSettings, Map map, GoogleApiAvailabilityLight googleApiAvailabilityLight, 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.EMPTY_SET;
+        for (Api.AnyClientKey anyClientKey : this.zaj) {
+            if (!this.zaa.zab.containsKey(anyClientKey)) {
+                this.zaa.zab.put(anyClientKey, new ConnectionResult(17, null));
+            }
+        }
+    }
+
+    private final void zaB(boolean z3) {
+        com.google.android.gms.signin.zae zaeVar = this.zak;
+        if (zaeVar != null) {
+            if (zaeVar.isConnected() && z3) {
+                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 z3) {
+        int priority = api.zac().getPriority();
+        if ((!z3 || connectionResult.hasResolution() || this.zad.getErrorResolutionIntent(connectionResult.getErrorCode()) != null) && (this.zae == null || priority < this.zaf)) {
+            this.zae = connectionResult;
+            this.zaf = priority;
+        }
+        this.zaa.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.EMPTY_SET;
+        }
+        HashSet hashSet = new HashSet(clientSettings.getRequiredScopes());
+        Map zad = zaawVar.zar.zad();
+        for (Api api : zad.keySet()) {
+            if (!zaawVar.zaa.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 z3 = false;
+        for (Api api : this.zas.keySet()) {
+            Api.Client client = (Api.Client) Preconditions.checkNotNull((Api.Client) this.zaa.zaa.get(api.zab()));
+            z3 |= 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 (z3) {
+            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;
+            Looper looper = this.zaa.zag.getLooper();
+            ClientSettings clientSettings = this.zar;
+            this.zak = abstractClientBuilder.buildClient(context, looper, 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(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 z3) {
+        if (zaG(1)) {
+            zaE(connectionResult, api, z3);
+            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;
+    }
+}

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

@@ -0,0 +1,62 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+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;
+import org.checkerframework.checker.initialization.qual.NotOnlyInitialized;
+
+/* loaded from: classes3.dex */
+public final class zaax implements zabf {
+
+    @NotOnlyInitialized
+    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.EMPTY_SET;
+    }
+
+    @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(Bundle bundle) {
+    }
+
+    @Override // com.google.android.gms.common.api.internal.zabf
+    public final void zah(ConnectionResult connectionResult, Api api, boolean z3) {
+    }
+
+    @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;
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.google.android.gms.common.api.internal;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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();
+    }
+}

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

@@ -0,0 +1,28 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+import com.google.android.gms.common.api.GoogleApiClient;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.atomic.AtomicReference;
+
+/* loaded from: classes3.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(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) {
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.google.android.gms.common.api.internal;
+
+import java.lang.ref.WeakReference;
+
+/* loaded from: classes3.dex */
+public final class zab extends ActivityLifecycleObserver {
+    private final WeakReference zaa;
+
+    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;
+    }
+}

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

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.api.internal;
+
+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: classes3.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(ConnectionResult connectionResult) {
+        this.zaa.setResult(new Status(8));
+    }
+}

apk_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 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;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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 z3, GoogleApiClient googleApiClient) {
+        this.zad = zabeVar;
+        this.zaa = statusPendingResult;
+        this.zab = z3;
+        this.zac = googleApiClient;
+    }
+
+    @Override // com.google.android.gms.common.api.ResultCallback
+    public final /* bridge */ /* synthetic */ void onResult(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();
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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);
+        } else {
+            if (i == 2) {
+                zabe.zai(this.zaa);
+                return;
+            }
+            Log.w("GoogleApiClientImpl", "Unknown message id: " + i);
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+package com.google.android.gms.common.api.internal;
+
+import java.lang.ref.WeakReference;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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);
+    }
+}

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

@@ -0,0 +1,723 @@
+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.fragment.app.P;
+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.android.gms.common.util.VisibleForTesting;
+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: classes3.dex */
+public final class zabe extends GoogleApiClient implements zabz {
+
+    @VisibleForTesting
+    zabx zab;
+    final Map zac;
+    Set zad;
+    final ClientSettings zae;
+    final Map zaf;
+    final Api.AbstractClientBuilder zag;
+    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;
+    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 i4, ArrayList arrayList) {
+        this.zaq = true != ClientLibraryUtils.isPackageSide() ? 120000L : 10000L;
+        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(i4);
+        }
+        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 z3) {
+        Iterator it = iterable.iterator();
+        boolean z4 = false;
+        boolean z5 = false;
+        while (it.hasNext()) {
+            Api.Client client = (Api.Client) it.next();
+            z4 |= client.requiresSignIn();
+            z5 |= client.providesSignIn();
+        }
+        if (z4) {
+            return (z5 && z3) ? 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) {
+        zabe zabeVar;
+        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 z3 = false;
+        boolean z4 = false;
+        for (Api.Client client : this.zac.values()) {
+            z3 |= client.requiresSignIn();
+            z4 |= client.providesSignIn();
+        }
+        int intValue = this.zaw.intValue();
+        if (intValue == 1) {
+            zabeVar = this;
+            if (!z3) {
+                throw new IllegalStateException("SIGN_IN_MODE_REQUIRED cannot be used on a GoogleApiClient that does not contain any authenticated APIs. Use connect() instead.");
+            }
+            if (z4) {
+                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 && z3) {
+                this.zal = zaaa.zag(this.zan, this, this.zaj, this.zao, this.zat, this.zac, this.zae, this.zaf, this.zag, this.zav);
+                return;
+            }
+            zabeVar = this;
+        }
+        zabeVar.zal = new zabi(zabeVar.zan, zabeVar, zabeVar.zaj, zabeVar.zao, zabeVar.zat, zabeVar.zac, zabeVar.zae, zabeVar.zaf, zabeVar.zag, zabeVar.zav, zabeVar);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public final void zam(GoogleApiClient googleApiClient, StatusPendingResult statusPendingResult, boolean z3) {
+        Common.zaa.zaa(googleApiClient).setResultCallback(new zabb(this, statusPendingResult, z3, googleApiClient));
+    }
+
+    private final void zan() {
+        this.zak.zab();
+        ((zaca) Preconditions.checkNotNull(this.zal)).zaq();
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final ConnectionResult blockingConnect() {
+        boolean z3 = 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) {
+                    z3 = false;
+                }
+                Preconditions.checkState(z3, "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 z3 = true;
+        if (num != null && num.intValue() == 2) {
+            z3 = false;
+        }
+        Preconditions.checkState(z3, "Cannot use clearDefaultAccountAndReconnect with GOOGLE_SIGN_IN_API");
+        StatusPendingResult statusPendingResult = new StatusPendingResult(this);
+        if (this.zac.containsKey(Common.CLIENT_KEY)) {
+            zam(this, statusPendingResult, false);
+            return statusPendingResult;
+        }
+        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 z3 = 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(z3, "Illegal sign-in mode: " + i);
+                    zal(i);
+                    zan();
+                    this.zaj.unlock();
+                    return;
+                }
+                Preconditions.checkArgument(z3, "Illegal sign-in mode: " + i);
+                zal(i);
+                zan();
+                this.zaj.unlock();
+                return;
+            } finally {
+                this.zaj.unlock();
+            }
+            z3 = true;
+        } catch (Throwable th) {
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void disconnect() {
+        Lock lock;
+        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) {
+                lock = this.zaj;
+            } else {
+                zak();
+                this.zak.zaa();
+                lock = this.zaj;
+            }
+            lock.unlock();
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, 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
+    public final <A extends Api.AnyClient, R extends Result, T extends BaseImplementation.ApiMethodImpl<R, A>> T enqueue(T t2) {
+        Lock lock;
+        Api<?> api = t2.getApi();
+        Preconditions.checkArgument(this.zac.containsKey(t2.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(t2);
+                lock = this.zaj;
+            } else {
+                t2 = (T) zacaVar.zae(t2);
+                lock = this.zaj;
+            }
+            lock.unlock();
+            return t2;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T execute(T t2) {
+        Lock lock;
+        Api<?> api = t2.getApi();
+        Preconditions.checkArgument(this.zac.containsKey(t2.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(t2);
+                while (!this.zaa.isEmpty()) {
+                    BaseImplementation.ApiMethodImpl apiMethodImpl = (BaseImplementation.ApiMethodImpl) this.zaa.remove();
+                    this.zai.zaa(apiMethodImpl);
+                    apiMethodImpl.setFailedResult(Status.RESULT_INTERNAL_ERROR);
+                }
+                lock = this.zaj;
+            } else {
+                t2 = (T) zacaVar.zaf(t2);
+                lock = this.zaj;
+            }
+            lock.unlock();
+            return t2;
+        } catch (Throwable th) {
+            this.zaj.unlock();
+            throw th;
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final <C extends Api.Client> C getClient(Api.AnyClientKey<C> anyClientKey) {
+        C c4 = (C) this.zac.get(anyClientKey);
+        Preconditions.checkNotNull(c4, "Appropriate Api was not requested.");
+        return c4;
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final ConnectionResult getConnectionResult(Api<?> api) {
+        ConnectionResult connectionResult;
+        Lock lock;
+        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;
+                lock = this.zaj;
+            } 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);
+                lock = this.zaj;
+            }
+            lock.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(Api<?> api) {
+        return this.zac.containsKey(api.zab());
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean hasConnectedApi(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(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        return this.zak.zaj(connectionCallbacks);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final boolean isConnectionFailedListenerRegistered(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(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        this.zak.zaf(connectionCallbacks);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void registerConnectionFailedListener(GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+        this.zak.zag(onConnectionFailedListener);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final <L> ListenerHolder<L> registerListener(L l4) {
+        this.zaj.lock();
+        try {
+            return this.zau.zaa(l4, this.zao, "NO_TYPE");
+        } finally {
+            this.zaj.unlock();
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void stopAutoManage(P p) {
+        LifecycleActivity lifecycleActivity = new LifecycleActivity((Activity) p);
+        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(GoogleApiClient.ConnectionCallbacks connectionCallbacks) {
+        this.zak.zah(connectionCallbacks);
+    }
+
+    @Override // com.google.android.gms.common.api.GoogleApiClient
+    public final void unregisterConnectionFailedListener(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(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 z3) {
+        if (i == 1) {
+            if (!z3 && !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();
+    }
+
+    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:23:0x0041, code lost:
+    
+        if (r3 != false) goto L20;
+     */
+    @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.Exception r3 = new java.lang.Exception     // Catch: java.lang.Throwable -> L16
+            r3.<init>()     // Catch: java.lang.Throwable -> L16
+            java.lang.String r0 = "Attempted to remove pending transform when no transforms are registered."
+            android.util.Log.wtf(r1, r0, r3)     // Catch: java.lang.Throwable -> L16
+            goto L4a
+        L16:
+            r3 = move-exception
+            goto L57
+        L18:
+            boolean r3 = r0.remove(r3)     // Catch: java.lang.Throwable -> L16
+            if (r3 != 0) goto L29
+            java.lang.Exception r3 = new java.lang.Exception     // Catch: java.lang.Throwable -> L16
+            r3.<init>()     // Catch: java.lang.Throwable -> L16
+            java.lang.String r0 = "Failed to remove pending transform - this may lead to memory leaks!"
+            android.util.Log.wtf(r1, r0, r3)     // Catch: java.lang.Throwable -> L16
+            goto L4a
+        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 -> L50
+            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 L43
+        L38:
+            boolean r3 = r3.isEmpty()     // Catch: java.lang.Throwable -> L50
+            java.util.concurrent.locks.Lock r0 = r2.zaj     // Catch: java.lang.Throwable -> L16
+            r0.unlock()     // Catch: java.lang.Throwable -> L16
+            if (r3 == 0) goto L4a
+        L43:
+            com.google.android.gms.common.api.internal.zaca r3 = r2.zal     // Catch: java.lang.Throwable -> L16
+            if (r3 == 0) goto L4a
+            r3.zat()     // Catch: java.lang.Throwable -> L16
+        L4a:
+            java.util.concurrent.locks.Lock r2 = r2.zaj
+            r2.unlock()
+            return
+        L50:
+            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
+        L57:
+            java.util.concurrent.locks.Lock r2 = r2.zaj
+            r2.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 j4, 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) {
+                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 zac = ((zaca) Preconditions.checkNotNull(this.zal)).zac(j4, 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 z3 = true;
+        if (i != 3 && i != 1) {
+            if (i == 2) {
+                i = 2;
+            } else {
+                z3 = false;
+            }
+        }
+        try {
+            Preconditions.checkArgument(z3, "Illegal sign-in mode: " + i);
+            zal(i);
+            zan();
+        } finally {
+            this.zaj.unlock();
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Bundle;
+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: classes3.dex */
+public interface zabf {
+    BaseImplementation.ApiMethodImpl zaa(BaseImplementation.ApiMethodImpl apiMethodImpl);
+
+    BaseImplementation.ApiMethodImpl zab(BaseImplementation.ApiMethodImpl apiMethodImpl);
+
+    void zad();
+
+    void zae();
+
+    void zag(Bundle bundle);
+
+    void zah(ConnectionResult connectionResult, Api api, boolean z3);
+
+    void zai(int i);
+
+    boolean zaj();
+}

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

@@ -0,0 +1,37 @@
+package com.google.android.gms.common.api.internal;
+
+import java.util.concurrent.locks.Lock;
+
+/* loaded from: classes3.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 lock3;
+        lock = zabiVar.zai;
+        lock.lock();
+        try {
+            zabfVar = zabiVar.zan;
+            if (zabfVar != this.zaa) {
+                lock3 = zabiVar.zai;
+            } else {
+                zaa();
+                lock3 = zabiVar.zai;
+            }
+            lock3.unlock();
+        } catch (Throwable th) {
+            lock2 = zabiVar.zai;
+            lock2.unlock();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/api/internal/zabh.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;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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);
+        }
+    }
+}

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

@@ -0,0 +1,263 @@
+package com.google.android.gms.common.api.internal;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.os.Looper;
+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;
+import org.checkerframework.checker.initialization.qual.NotOnlyInitialized;
+
+/* loaded from: classes3.dex */
+public final class zabi implements zaca, zau {
+    final Map zaa;
+    final ClientSettings zac;
+    final Map zad;
+    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;
+
+    @NotOnlyInitialized
+    private volatile zabf zan;
+    final Map zab = new HashMap();
+    private ConnectionResult zao = null;
+
+    public zabi(Context context, zabe zabeVar, Lock lock, Looper looper, GoogleApiAvailabilityLight googleApiAvailabilityLight, Map map, ClientSettings clientSettings, Map map2, 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(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(ConnectionResult connectionResult, Api api, boolean z3) {
+        this.zai.lock();
+        try {
+            this.zan.zah(connectionResult, api, z3);
+        } 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 j4, TimeUnit timeUnit) {
+        zaq();
+        long nanos = timeUnit.toNanos(j4);
+        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
+    public final ConnectionResult zad(Api api) {
+        Api.AnyClientKey zab = api.zab();
+        if (!this.zaa.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(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(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() {
+        zabi zabiVar;
+        this.zai.lock();
+        try {
+            zabiVar = this;
+            try {
+                zabiVar.zan = new zaaw(zabiVar, this.zac, this.zad, this.zal, this.zae, this.zai, this.zak);
+                zabiVar.zan.zad();
+                zabiVar.zaj.signalAll();
+                zabiVar.zai.unlock();
+            } catch (Throwable th) {
+                th = th;
+                Throwable th2 = th;
+                zabiVar.zai.unlock();
+                throw th2;
+            }
+        } catch (Throwable th3) {
+            th = th3;
+            zabiVar = this;
+        }
+    }
+
+    public final void zak(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) {
+        this.zam.sendMessage(this.zam.obtainMessage(1, zabgVar));
+    }
+
+    public final void zam(RuntimeException runtimeException) {
+        this.zam.sendMessage(this.zam.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, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        String concat = String.valueOf(str).concat("  ");
+        printWriter.append((CharSequence) str).append("mState=").println(this.zan);
+        for (Api api : this.zad.keySet()) {
+            printWriter.append((CharSequence) str).append((CharSequence) api.zad()).println(":");
+            ((Api.Client) Preconditions.checkNotNull((Api.Client) this.zaa.get(api.zab()))).dump(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;
+    }
+}

apk_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: classes3.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;
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.google.android.gms.common.api.internal;
+
+import android.os.Handler;
+import com.google.android.gms.common.api.internal.BackgroundDetector;
+
+/* loaded from: classes3.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 z3) {
+        Handler handler;
+        Handler handler2;
+        GoogleApiManager googleApiManager = this.zaa;
+        handler = googleApiManager.zat;
+        handler2 = googleApiManager.zat;
+        handler.sendMessage(handler2.obtainMessage(1, Boolean.valueOf(z3)));
+    }
+}

apk_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: classes3.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.zaG();
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.api.internal;
+
+/* JADX INFO: Access modifiers changed from: package-private */
+/* loaded from: classes3.dex */
+public 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.zaH(this.zaa);
+    }
+}

apk_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: classes3.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."));
+    }
+}