Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/com/google/android/gms/common/AccountPicker.java

@@ -0,0 +1,205 @@
+package com.google.android.gms.common;
+
+import android.accounts.Account;
+import android.content.Intent;
+import android.os.Bundle;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+public final class AccountPicker {
+
+    /* loaded from: classes3.dex */
+    public static class AccountChooserOptions {
+        private Account zza;
+        private boolean zzb;
+        private ArrayList zzc;
+        private ArrayList zzd;
+        private boolean zze;
+        private String zzf;
+        private Bundle zzg;
+        private boolean zzh;
+        private int zzi;
+        private String zzj;
+        private boolean zzk;
+        private zza zzl;
+        private String zzm;
+        private boolean zzn;
+        private boolean zzo;
+
+        /* loaded from: classes3.dex */
+        public static class Builder {
+            private Account zza;
+            private ArrayList zzb;
+            private ArrayList zzc;
+            private boolean zzd = false;
+            private String zze;
+            private Bundle zzf;
+
+            public AccountChooserOptions build() {
+                Preconditions.checkArgument(true, "We only support hostedDomain filter for account chip styled account picker");
+                Preconditions.checkArgument(true, "Consent is only valid for account chip styled account picker");
+                AccountChooserOptions accountChooserOptions = new AccountChooserOptions();
+                accountChooserOptions.zzd = this.zzc;
+                accountChooserOptions.zzc = this.zzb;
+                accountChooserOptions.zze = this.zzd;
+                accountChooserOptions.zzl = null;
+                accountChooserOptions.zzj = null;
+                accountChooserOptions.zzg = this.zzf;
+                accountChooserOptions.zza = this.zza;
+                accountChooserOptions.zzb = false;
+                accountChooserOptions.zzh = false;
+                accountChooserOptions.zzm = null;
+                accountChooserOptions.zzi = 0;
+                accountChooserOptions.zzf = this.zze;
+                accountChooserOptions.zzk = false;
+                accountChooserOptions.zzn = false;
+                accountChooserOptions.zzo = false;
+                return accountChooserOptions;
+            }
+
+            public Builder setAllowableAccounts(List<Account> list) {
+                this.zzb = list == null ? null : new ArrayList(list);
+                return this;
+            }
+
+            public Builder setAllowableAccountsTypes(List<String> list) {
+                this.zzc = list == null ? null : new ArrayList(list);
+                return this;
+            }
+
+            public Builder setAlwaysShowAccountPicker(boolean z3) {
+                this.zzd = z3;
+                return this;
+            }
+
+            public Builder setOptionsForAddingAccount(Bundle bundle) {
+                this.zzf = bundle;
+                return this;
+            }
+
+            public Builder setSelectedAccount(Account account) {
+                this.zza = account;
+                return this;
+            }
+
+            public Builder setTitleOverrideText(String str) {
+                this.zze = str;
+                return this;
+            }
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzA(AccountChooserOptions accountChooserOptions) {
+            boolean z3 = accountChooserOptions.zzo;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzB(AccountChooserOptions accountChooserOptions) {
+            boolean z3 = accountChooserOptions.zzb;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzC(AccountChooserOptions accountChooserOptions) {
+            boolean z3 = accountChooserOptions.zzh;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzD(AccountChooserOptions accountChooserOptions) {
+            boolean z3 = accountChooserOptions.zzk;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ int zza(AccountChooserOptions accountChooserOptions) {
+            int i = accountChooserOptions.zzi;
+            return 0;
+        }
+
+        public static /* bridge */ /* synthetic */ zza zzd(AccountChooserOptions accountChooserOptions) {
+            zza zzaVar = accountChooserOptions.zzl;
+            return null;
+        }
+
+        public static /* bridge */ /* synthetic */ String zze(AccountChooserOptions accountChooserOptions) {
+            String str = accountChooserOptions.zzj;
+            return null;
+        }
+
+        public static /* bridge */ /* synthetic */ String zzf(AccountChooserOptions accountChooserOptions) {
+            String str = accountChooserOptions.zzm;
+            return null;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzz(AccountChooserOptions accountChooserOptions) {
+            boolean z3 = accountChooserOptions.zzn;
+            return false;
+        }
+    }
+
+    private AccountPicker() {
+    }
+
+    @Deprecated
+    public static Intent newChooseAccountIntent(Account account, ArrayList<Account> arrayList, String[] strArr, boolean z3, String str, String str2, String[] strArr2, Bundle bundle) {
+        Intent intent = new Intent();
+        Preconditions.checkArgument(true, "We only support hostedDomain filter for account chip styled account picker");
+        intent.setAction("com.google.android.gms.common.account.CHOOSE_ACCOUNT");
+        intent.setPackage("com.google.android.gms");
+        intent.putExtra("allowableAccounts", arrayList);
+        intent.putExtra("allowableAccountTypes", strArr);
+        intent.putExtra("addAccountOptions", bundle);
+        intent.putExtra("selectedAccount", account);
+        intent.putExtra("alwaysPromptForAccount", z3);
+        intent.putExtra("descriptionTextOverride", str);
+        intent.putExtra("authTokenType", str2);
+        intent.putExtra("addAccountRequiredFeatures", strArr2);
+        intent.putExtra("setGmsCoreAccount", false);
+        intent.putExtra("overrideTheme", 0);
+        intent.putExtra("overrideCustomTheme", 0);
+        intent.putExtra("hostedDomainFilter", (String) null);
+        return intent;
+    }
+
+    public static Intent newChooseAccountIntent(AccountChooserOptions accountChooserOptions) {
+        Intent intent = new Intent();
+        AccountChooserOptions.zzD(accountChooserOptions);
+        AccountChooserOptions.zze(accountChooserOptions);
+        Preconditions.checkArgument(true, "We only support hostedDomain filter for account chip styled account picker");
+        AccountChooserOptions.zzd(accountChooserOptions);
+        Preconditions.checkArgument(true, "Consent is only valid for account chip styled account picker");
+        AccountChooserOptions.zzB(accountChooserOptions);
+        Preconditions.checkArgument(true, "Making the selected account non-clickable is only supported for the theme THEME_DAY_NIGHT_GOOGLE_MATERIAL2");
+        AccountChooserOptions.zzD(accountChooserOptions);
+        intent.setAction("com.google.android.gms.common.account.CHOOSE_ACCOUNT");
+        intent.setPackage("com.google.android.gms");
+        intent.putExtra("allowableAccounts", accountChooserOptions.zzc);
+        if (accountChooserOptions.zzd != null) {
+            intent.putExtra("allowableAccountTypes", (String[]) accountChooserOptions.zzd.toArray(new String[0]));
+        }
+        intent.putExtra("addAccountOptions", accountChooserOptions.zzg);
+        intent.putExtra("selectedAccount", accountChooserOptions.zza);
+        AccountChooserOptions.zzB(accountChooserOptions);
+        intent.putExtra("selectedAccountIsNotClickable", false);
+        intent.putExtra("alwaysPromptForAccount", accountChooserOptions.zze);
+        intent.putExtra("descriptionTextOverride", accountChooserOptions.zzf);
+        AccountChooserOptions.zzC(accountChooserOptions);
+        intent.putExtra("setGmsCoreAccount", false);
+        AccountChooserOptions.zzf(accountChooserOptions);
+        intent.putExtra("realClientPackage", (String) null);
+        AccountChooserOptions.zza(accountChooserOptions);
+        intent.putExtra("overrideTheme", 0);
+        AccountChooserOptions.zzD(accountChooserOptions);
+        intent.putExtra("overrideCustomTheme", 0);
+        AccountChooserOptions.zze(accountChooserOptions);
+        intent.putExtra("hostedDomainFilter", (String) null);
+        Bundle bundle = new Bundle();
+        AccountChooserOptions.zzD(accountChooserOptions);
+        AccountChooserOptions.zzd(accountChooserOptions);
+        AccountChooserOptions.zzz(accountChooserOptions);
+        AccountChooserOptions.zzA(accountChooserOptions);
+        if (!bundle.isEmpty()) {
+            intent.putExtra("first_party_options_bundle", bundle);
+        }
+        return intent;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/BlockingServiceConnection.java

@@ -0,0 +1,51 @@
+package com.google.android.gms.common;
+
+import android.content.ComponentName;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class BlockingServiceConnection implements ServiceConnection {
+    boolean zza = false;
+    private final BlockingQueue zzb = new LinkedBlockingQueue();
+
+    @KeepForSdk
+    public IBinder getService() throws InterruptedException {
+        Preconditions.checkNotMainThread("BlockingServiceConnection.getService() called on main thread");
+        if (this.zza) {
+            throw new IllegalStateException("Cannot call get on this connection more than once");
+        }
+        this.zza = true;
+        return (IBinder) this.zzb.take();
+    }
+
+    @KeepForSdk
+    public IBinder getServiceWithTimeout(long j4, TimeUnit timeUnit) throws InterruptedException, TimeoutException {
+        Preconditions.checkNotMainThread("BlockingServiceConnection.getServiceWithTimeout() called on main thread");
+        if (this.zza) {
+            throw new IllegalStateException("Cannot call get on this connection more than once");
+        }
+        this.zza = true;
+        IBinder iBinder = (IBinder) this.zzb.poll(j4, timeUnit);
+        if (iBinder != null) {
+            return iBinder;
+        }
+        throw new TimeoutException("Timed out waiting for the service connection");
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceConnected(ComponentName componentName, IBinder iBinder) {
+        this.zzb.add(iBinder);
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceDisconnected(ComponentName componentName) {
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/ConnectionResult.java

@@ -0,0 +1,213 @@
+package com.google.android.gms.common;
+
+import C.w;
+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.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.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;
+
+@SafeParcelable.Class(creator = "ConnectionResultCreator")
+/* loaded from: classes3.dex */
+public final class ConnectionResult extends AbstractSafeParcelable {
+    public static final int API_DISABLED = 23;
+    public static final int API_DISABLED_FOR_CONNECTION = 24;
+    public static final int API_UNAVAILABLE = 16;
+    public static final int CANCELED = 13;
+    public static final int DEVELOPER_ERROR = 10;
+
+    @Deprecated
+    public static final int DRIVE_EXTERNAL_STORAGE_REQUIRED = 1500;
+    public static final int INTERNAL_ERROR = 8;
+    public static final int INTERRUPTED = 15;
+    public static final int INVALID_ACCOUNT = 5;
+    public static final int LICENSE_CHECK_FAILED = 11;
+    public static final int NETWORK_ERROR = 7;
+    public static final int RESOLUTION_ACTIVITY_NOT_FOUND = 22;
+    public static final int RESOLUTION_REQUIRED = 6;
+    public static final int RESTRICTED_PROFILE = 20;
+    public static final int SERVICE_DISABLED = 3;
+    public static final int SERVICE_INVALID = 9;
+    public static final int SERVICE_MISSING = 1;
+    public static final int SERVICE_MISSING_PERMISSION = 19;
+    public static final int SERVICE_UPDATING = 18;
+    public static final int SERVICE_VERSION_UPDATE_REQUIRED = 2;
+    public static final int SIGN_IN_FAILED = 17;
+    public static final int SIGN_IN_REQUIRED = 4;
+    public static final int SUCCESS = 0;
+    public static final int TIMEOUT = 14;
+
+    @KeepForSdk
+    public static final int UNKNOWN = -1;
+
+    @SafeParcelable.VersionField(id = 1)
+    final int zza;
+
+    @SafeParcelable.Field(getter = "getErrorCode", id = 2)
+    private final int zzb;
+
+    @SafeParcelable.Field(getter = "getResolution", id = 3)
+    private final PendingIntent zzc;
+
+    @SafeParcelable.Field(getter = "getErrorMessage", id = 4)
+    private final String zzd;
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static final ConnectionResult RESULT_SUCCESS = new ConnectionResult(0);
+    public static final Parcelable.Creator<ConnectionResult> CREATOR = new zzb();
+
+    @SafeParcelable.Constructor
+    public ConnectionResult(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) int i4, @SafeParcelable.Param(id = 3) PendingIntent pendingIntent, @SafeParcelable.Param(id = 4) String str) {
+        this.zza = i;
+        this.zzb = i4;
+        this.zzc = pendingIntent;
+        this.zzd = str;
+    }
+
+    public static String zza(int i) {
+        if (i == 99) {
+            return "UNFINISHED";
+        }
+        if (i == 1500) {
+            return "DRIVE_EXTERNAL_STORAGE_REQUIRED";
+        }
+        switch (i) {
+            case -1:
+                return "UNKNOWN";
+            case 0:
+                return "SUCCESS";
+            case 1:
+                return "SERVICE_MISSING";
+            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 9:
+                return "SERVICE_INVALID";
+            case 10:
+                return "DEVELOPER_ERROR";
+            case 11:
+                return "LICENSE_CHECK_FAILED";
+            default:
+                switch (i) {
+                    case 13:
+                        return "CANCELED";
+                    case 14:
+                        return "TIMEOUT";
+                    case 15:
+                        return "INTERRUPTED";
+                    case 16:
+                        return "API_UNAVAILABLE";
+                    case 17:
+                        return "SIGN_IN_FAILED";
+                    case 18:
+                        return "SERVICE_UPDATING";
+                    case 19:
+                        return "SERVICE_MISSING_PERMISSION";
+                    case 20:
+                        return "RESTRICTED_PROFILE";
+                    case 21:
+                        return "API_VERSION_UPDATE_REQUIRED";
+                    case 22:
+                        return "RESOLUTION_ACTIVITY_NOT_FOUND";
+                    case 23:
+                        return "API_DISABLED";
+                    case 24:
+                        return "API_DISABLED_FOR_CONNECTION";
+                    default:
+                        return w.i(i, "UNKNOWN_ERROR_CODE(", ")");
+                }
+        }
+    }
+
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof ConnectionResult)) {
+            return false;
+        }
+        ConnectionResult connectionResult = (ConnectionResult) obj;
+        return this.zzb == connectionResult.zzb && Objects.equal(this.zzc, connectionResult.zzc) && Objects.equal(this.zzd, connectionResult.zzd);
+    }
+
+    public int getErrorCode() {
+        return this.zzb;
+    }
+
+    public String getErrorMessage() {
+        return this.zzd;
+    }
+
+    public PendingIntent getResolution() {
+        return this.zzc;
+    }
+
+    public boolean hasResolution() {
+        return (this.zzb == 0 || this.zzc == null) ? false : true;
+    }
+
+    public int hashCode() {
+        return Objects.hashCode(Integer.valueOf(this.zzb), this.zzc, this.zzd);
+    }
+
+    public boolean isSuccess() {
+        return this.zzb == 0;
+    }
+
+    public void startResolutionForResult(Activity activity, int i) throws IntentSender.SendIntentException {
+        if (hasResolution()) {
+            PendingIntent pendingIntent = this.zzc;
+            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(this.zzb));
+        stringHelper.add("resolution", this.zzc);
+        stringHelper.add("message", this.zzd);
+        return stringHelper.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, this.zza);
+        SafeParcelWriter.writeInt(parcel, 2, getErrorCode());
+        SafeParcelWriter.writeParcelable(parcel, 3, getResolution(), i, false);
+        SafeParcelWriter.writeString(parcel, 4, getErrorMessage(), false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public ConnectionResult(int i) {
+        this(i, null, null);
+    }
+
+    public ConnectionResult(int i, PendingIntent pendingIntent) {
+        this(i, pendingIntent, null);
+    }
+
+    public ConnectionResult(int i, PendingIntent pendingIntent, String str) {
+        this(1, i, pendingIntent, str);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/ErrorDialogFragment.java

@@ -0,0 +1,59 @@
+package com.google.android.gms.common;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.app.FragmentManager;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public class ErrorDialogFragment extends DialogFragment {
+    private Dialog zaa;
+    private DialogInterface.OnCancelListener zab;
+    private Dialog zac;
+
+    public static ErrorDialogFragment newInstance(Dialog dialog) {
+        return newInstance(dialog, null);
+    }
+
+    @Override // android.app.DialogFragment, android.content.DialogInterface.OnCancelListener
+    public void onCancel(DialogInterface dialogInterface) {
+        DialogInterface.OnCancelListener onCancelListener = this.zab;
+        if (onCancelListener != null) {
+            onCancelListener.onCancel(dialogInterface);
+        }
+    }
+
+    @Override // android.app.DialogFragment
+    public Dialog onCreateDialog(Bundle bundle) {
+        Dialog dialog = this.zaa;
+        if (dialog != null) {
+            return dialog;
+        }
+        setShowsDialog(false);
+        if (this.zac == null) {
+            this.zac = new AlertDialog.Builder((Context) Preconditions.checkNotNull(getActivity())).create();
+        }
+        return this.zac;
+    }
+
+    @Override // android.app.DialogFragment
+    public void show(FragmentManager fragmentManager, String str) {
+        super.show(fragmentManager, str);
+    }
+
+    public static ErrorDialogFragment newInstance(Dialog dialog, DialogInterface.OnCancelListener onCancelListener) {
+        ErrorDialogFragment errorDialogFragment = new ErrorDialogFragment();
+        Dialog dialog2 = (Dialog) Preconditions.checkNotNull(dialog, "Cannot display null dialog");
+        dialog2.setOnCancelListener(null);
+        dialog2.setOnDismissListener(null);
+        errorDialogFragment.zaa = dialog2;
+        if (onCancelListener != null) {
+            errorDialogFragment.zab = onCancelListener;
+        }
+        return errorDialogFragment;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/Feature.java

@@ -0,0 +1,82 @@
+package com.google.android.gms.common;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Objects;
+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.measurement.api.AppMeasurementSdk;
+
+@KeepForSdk
+@SafeParcelable.Class(creator = "FeatureCreator")
+/* loaded from: classes3.dex */
+public class Feature extends AbstractSafeParcelable {
+    public static final Parcelable.Creator<Feature> CREATOR = new zzc();
+
+    @SafeParcelable.Field(getter = "getName", id = 1)
+    private final String zza;
+
+    @SafeParcelable.Field(getter = "getOldVersion", id = 2)
+    @Deprecated
+    private final int zzb;
+
+    @SafeParcelable.Field(defaultValue = "-1", getter = "getVersion", id = 3)
+    private final long zzc;
+
+    @SafeParcelable.Constructor
+    public Feature(@SafeParcelable.Param(id = 1) String str, @SafeParcelable.Param(id = 2) int i, @SafeParcelable.Param(id = 3) long j4) {
+        this.zza = str;
+        this.zzb = i;
+        this.zzc = j4;
+    }
+
+    public final boolean equals(Object obj) {
+        if (obj instanceof Feature) {
+            Feature feature = (Feature) obj;
+            if (((getName() != null && getName().equals(feature.getName())) || (getName() == null && feature.getName() == null)) && getVersion() == feature.getVersion()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    public String getName() {
+        return this.zza;
+    }
+
+    @KeepForSdk
+    public long getVersion() {
+        long j4 = this.zzc;
+        return j4 == -1 ? this.zzb : j4;
+    }
+
+    public final int hashCode() {
+        return Objects.hashCode(getName(), Long.valueOf(getVersion()));
+    }
+
+    public final String toString() {
+        Objects.ToStringHelper stringHelper = Objects.toStringHelper(this);
+        stringHelper.add(AppMeasurementSdk.ConditionalUserProperty.NAME, getName());
+        stringHelper.add("version", Long.valueOf(getVersion()));
+        return stringHelper.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeString(parcel, 1, getName(), false);
+        SafeParcelWriter.writeInt(parcel, 2, this.zzb);
+        SafeParcelWriter.writeLong(parcel, 3, getVersion());
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @KeepForSdk
+    public Feature(String str, long j4) {
+        this.zza = str;
+        this.zzc = j4;
+        this.zzb = -1;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/FirstPartyScopes.java

@@ -0,0 +1,16 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class FirstPartyScopes {
+
+    @KeepForSdk
+    public static final String GAMES_1P = "https://www.googleapis.com/auth/games.firstparty";
+
+    private FirstPartyScopes() {
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GmsSignatureVerifier.java

@@ -0,0 +1,35 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.internal.common.zzag;
+import com.google.errorprone.annotations.RestrictedInheritance;
+import java.util.HashMap;
+
+@ShowFirstParty
+@KeepForSdk
+@RestrictedInheritance(allowedOnPath = ".*javatests/com/google/android/gmscore/integ/client/common/robolectric/.*", explanation = "Sub classing of GMS Core's APIs are restricted to testing fakes.", link = "go/gmscore-restrictedinheritance")
+/* loaded from: classes3.dex */
+public class GmsSignatureVerifier {
+    private static final zzab zza;
+    private static final zzab zzb;
+    private static final HashMap zzc;
+
+    static {
+        zzz zzzVar = new zzz();
+        zzzVar.zzd("com.google.android.gms");
+        zzzVar.zza(204200000L);
+        zzl zzlVar = zzn.zzd;
+        zzzVar.zzc(zzag.zzn(zzlVar.zzf(), zzn.zzb.zzf()));
+        zzl zzlVar2 = zzn.zzc;
+        zzzVar.zzb(zzag.zzn(zzlVar2.zzf(), zzn.zza.zzf()));
+        zza = zzzVar.zze();
+        zzz zzzVar2 = new zzz();
+        zzzVar2.zzd("com.android.vending");
+        zzzVar2.zza(82240000L);
+        zzzVar2.zzc(zzag.zzm(zzlVar.zzf()));
+        zzzVar2.zzb(zzag.zzm(zzlVar2.zzf()));
+        zzb = zzzVar2.zze();
+        zzc = new HashMap();
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GoogleApiAvailability.java

@@ -0,0 +1,363 @@
+package com.google.android.gms.common;
+
+import C.o;
+import C.u;
+import C.w;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.res.Resources;
+import android.util.Log;
+import android.util.TypedValue;
+import android.widget.ProgressBar;
+import androidx.fragment.app.K;
+import androidx.fragment.app.P;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.GoogleApi;
+import com.google.android.gms.common.api.GoogleApiActivity;
+import com.google.android.gms.common.api.HasApiKey;
+import com.google.android.gms.common.api.internal.GoogleApiManager;
+import com.google.android.gms.common.api.internal.LifecycleFragment;
+import com.google.android.gms.common.api.internal.zabw;
+import com.google.android.gms.common.api.internal.zabx;
+import com.google.android.gms.common.api.internal.zacc;
+import com.google.android.gms.common.internal.HideFirstParty;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.zag;
+import com.google.android.gms.common.util.DeviceProperties;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.common.wrappers.InstantApps;
+import com.google.android.gms.internal.base.zad;
+import com.google.android.gms.internal.base.zae;
+import com.google.android.gms.internal.base.zao;
+import com.google.android.gms.internal.base.zap;
+import com.google.android.gms.measurement.internal.a;
+import com.google.android.gms.tasks.SuccessContinuation;
+import com.google.android.gms.tasks.Task;
+import com.google.android.gms.tasks.Tasks;
+import com.google.errorprone.annotations.RestrictedInheritance;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+@RestrictedInheritance(allowedOnPath = ".*java.*/com/google/android/gms.*", allowlistAnnotations = {zad.class, zae.class}, explanation = "Sub classing of GMS Core's APIs are restricted to GMS Core client libs and testing fakes.", link = "go/gmscore-restrictedinheritance")
+/* loaded from: classes3.dex */
+public class GoogleApiAvailability extends GoogleApiAvailabilityLight {
+    public static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
+    private String zac;
+    private static final Object zaa = new Object();
+    private static final GoogleApiAvailability zab = new GoogleApiAvailability();
+    public static final int GOOGLE_PLAY_SERVICES_VERSION_CODE = GoogleApiAvailabilityLight.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+
+    public static GoogleApiAvailability getInstance() {
+        return zab;
+    }
+
+    public static final Task zai(HasApiKey hasApiKey, HasApiKey... hasApiKeyArr) {
+        Preconditions.checkNotNull(hasApiKey, "Requested API must not be null.");
+        for (HasApiKey hasApiKey2 : hasApiKeyArr) {
+            Preconditions.checkNotNull(hasApiKey2, "Requested API must not be null.");
+        }
+        ArrayList arrayList = new ArrayList(hasApiKeyArr.length + 1);
+        arrayList.add(hasApiKey);
+        arrayList.addAll(Arrays.asList(hasApiKeyArr));
+        return GoogleApiManager.zal().zao(arrayList);
+    }
+
+    public Task<Void> checkApiAvailability(GoogleApi<?> googleApi, GoogleApi<?>... googleApiArr) {
+        return zai(googleApi, googleApiArr).onSuccessTask(new SuccessContinuation() { // from class: com.google.android.gms.common.zab
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public final Task then(Object obj) {
+                int i = GoogleApiAvailability.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+                return Tasks.forResult(null);
+            }
+        });
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @ShowFirstParty
+    @KeepForSdk
+    public int getClientVersion(Context context) {
+        return super.getClientVersion(context);
+    }
+
+    public Dialog getErrorDialog(Activity activity, int i, int i4) {
+        return getErrorDialog(activity, i, i4, (DialogInterface.OnCancelListener) null);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @ShowFirstParty
+    @KeepForSdk
+    public Intent getErrorResolutionIntent(Context context, int i, String str) {
+        return super.getErrorResolutionIntent(context, i, str);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    public PendingIntent getErrorResolutionPendingIntent(Context context, int i, int i4) {
+        return super.getErrorResolutionPendingIntent(context, i, i4);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    public final String getErrorString(int i) {
+        return super.getErrorString(i);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @HideFirstParty
+    public int isGooglePlayServicesAvailable(Context context) {
+        return super.isGooglePlayServicesAvailable(context);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    public final boolean isUserResolvableError(int i) {
+        return super.isUserResolvableError(i);
+    }
+
+    public Task<Void> makeGooglePlayServicesAvailable(Activity activity) {
+        int i = GOOGLE_PLAY_SERVICES_VERSION_CODE;
+        Preconditions.checkMainThread("makeGooglePlayServicesAvailable must be called from the main thread");
+        int isGooglePlayServicesAvailable = isGooglePlayServicesAvailable(activity, i);
+        if (isGooglePlayServicesAvailable == 0) {
+            return Tasks.forResult(null);
+        }
+        zacc zaa2 = zacc.zaa(activity);
+        zaa2.zah(new ConnectionResult(isGooglePlayServicesAvailable, null), 0);
+        return zaa2.zad();
+    }
+
+    @TargetApi(26)
+    public void setDefaultNotificationChannelId(Context context, String str) {
+        if (PlatformVersion.isAtLeastO()) {
+            Preconditions.checkNotNull(((NotificationManager) Preconditions.checkNotNull(context.getSystemService("notification"))).getNotificationChannel(str));
+        }
+        synchronized (zaa) {
+            this.zac = str;
+        }
+    }
+
+    public boolean showErrorDialogFragment(Activity activity, int i, int i4) {
+        return showErrorDialogFragment(activity, i, i4, null);
+    }
+
+    public void showErrorNotification(Context context, int i) {
+        zae(context, i, null, getErrorResolutionPendingIntent(context, i, 0, "n"));
+    }
+
+    public final Dialog zaa(Context context, int i, zag zagVar, DialogInterface.OnCancelListener onCancelListener) {
+        if (i == 0) {
+            return null;
+        }
+        TypedValue typedValue = new TypedValue();
+        context.getTheme().resolveAttribute(android.R.attr.alertDialogTheme, typedValue, true);
+        AlertDialog.Builder builder = "Theme.Dialog.Alert".equals(context.getResources().getResourceEntryName(typedValue.resourceId)) ? new AlertDialog.Builder(context, 5) : null;
+        if (builder == null) {
+            builder = new AlertDialog.Builder(context);
+        }
+        builder.setMessage(com.google.android.gms.common.internal.zac.zad(context, i));
+        if (onCancelListener != null) {
+            builder.setOnCancelListener(onCancelListener);
+        }
+        String zac = com.google.android.gms.common.internal.zac.zac(context, i);
+        if (zac != null) {
+            builder.setPositiveButton(zac, zagVar);
+        }
+        String zag = com.google.android.gms.common.internal.zac.zag(context, i);
+        if (zag != null) {
+            builder.setTitle(zag);
+        }
+        Log.w("GoogleApiAvailability", a.l(i, "Creating dialog for Google Play services availability issue. ConnectionResult="), new IllegalArgumentException());
+        return builder.create();
+    }
+
+    public final Dialog zab(Activity activity, DialogInterface.OnCancelListener onCancelListener) {
+        ProgressBar progressBar = new ProgressBar(activity, null, android.R.attr.progressBarStyleLarge);
+        progressBar.setIndeterminate(true);
+        progressBar.setVisibility(0);
+        AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+        builder.setView(progressBar);
+        builder.setMessage(com.google.android.gms.common.internal.zac.zad(activity, 18));
+        builder.setPositiveButton("", (DialogInterface.OnClickListener) null);
+        AlertDialog create = builder.create();
+        zad(activity, create, "GooglePlayServicesUpdatingDialog", onCancelListener);
+        return create;
+    }
+
+    public final zabx zac(Context context, zabw zabwVar) {
+        IntentFilter intentFilter = new IntentFilter("android.intent.action.PACKAGE_ADDED");
+        intentFilter.addDataScheme("package");
+        zabx zabxVar = new zabx(zabwVar);
+        zao.zaa(context, zabxVar, intentFilter);
+        zabxVar.zaa(context);
+        if (isUninstalledAppPossiblyUpdating(context, "com.google.android.gms")) {
+            return zabxVar;
+        }
+        zabwVar.zaa();
+        zabxVar.zab();
+        return null;
+    }
+
+    public final void zad(Activity activity, Dialog dialog, String str, DialogInterface.OnCancelListener onCancelListener) {
+        try {
+            if (activity instanceof P) {
+                SupportErrorDialogFragment.newInstance(dialog, onCancelListener).show(((P) activity).getSupportFragmentManager(), str);
+                return;
+            }
+        } catch (NoClassDefFoundError unused) {
+        }
+        ErrorDialogFragment.newInstance(dialog, onCancelListener).show(activity.getFragmentManager(), str);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r11v6, types: [C.s, java.lang.Object, C.v] */
+    @TargetApi(20)
+    public final void zae(Context context, int i, String str, PendingIntent pendingIntent) {
+        int i4;
+        String str2;
+        Log.w("GoogleApiAvailability", w.i(i, "GMS core API Availability. ConnectionResult=", ", tag=null"), new IllegalArgumentException());
+        if (i == 18) {
+            zaf(context);
+            return;
+        }
+        if (pendingIntent == null) {
+            if (i == 6) {
+                Log.w("GoogleApiAvailability", "Missing resolution for ConnectionResult.RESOLUTION_REQUIRED. Call GoogleApiAvailability#showErrorNotification(Context, ConnectionResult) instead.");
+                return;
+            }
+            return;
+        }
+        String zaf = com.google.android.gms.common.internal.zac.zaf(context, i);
+        String zae = com.google.android.gms.common.internal.zac.zae(context, i);
+        Resources resources = context.getResources();
+        NotificationManager notificationManager = (NotificationManager) Preconditions.checkNotNull(context.getSystemService("notification"));
+        u uVar = new u(context, null);
+        uVar.f260o = true;
+        uVar.c(true);
+        uVar.f252e = u.b(zaf);
+        ?? obj = new Object();
+        obj.f247b = u.b(zae);
+        uVar.e(obj);
+        if (DeviceProperties.isWearable(context)) {
+            Preconditions.checkState(PlatformVersion.isAtLeastKitKatWatch());
+            uVar.f265u.icon = context.getApplicationInfo().icon;
+            uVar.f255j = 2;
+            if (DeviceProperties.isWearableWithoutPlayStore(context)) {
+                uVar.f249b.add(new o(com.google.android.gms.base.R.drawable.common_full_open_on_phone, resources.getString(com.google.android.gms.base.R.string.common_open_on_phone), pendingIntent));
+            } else {
+                uVar.f254g = pendingIntent;
+            }
+        } else {
+            uVar.f265u.icon = android.R.drawable.stat_sys_warning;
+            String string = resources.getString(com.google.android.gms.base.R.string.common_google_play_services_notification_ticker);
+            uVar.f265u.tickerText = u.b(string);
+            uVar.f265u.when = System.currentTimeMillis();
+            uVar.f254g = pendingIntent;
+            uVar.f253f = u.b(zae);
+        }
+        if (PlatformVersion.isAtLeastO()) {
+            Preconditions.checkState(PlatformVersion.isAtLeastO());
+            synchronized (zaa) {
+                str2 = this.zac;
+            }
+            if (str2 == null) {
+                str2 = "com.google.android.gms.availability";
+                NotificationChannel notificationChannel = notificationManager.getNotificationChannel("com.google.android.gms.availability");
+                String zab2 = com.google.android.gms.common.internal.zac.zab(context);
+                if (notificationChannel == null) {
+                    notificationManager.createNotificationChannel(new NotificationChannel("com.google.android.gms.availability", zab2, 4));
+                } else if (!zab2.contentEquals(notificationChannel.getName())) {
+                    notificationChannel.setName(zab2);
+                    notificationManager.createNotificationChannel(notificationChannel);
+                }
+            }
+            uVar.f263s = str2;
+        }
+        Notification a2 = uVar.a();
+        if (i == 1 || i == 2 || i == 3) {
+            GooglePlayServicesUtilLight.sCanceledAvailabilityNotification.set(false);
+            i4 = 10436;
+        } else {
+            i4 = 39789;
+        }
+        notificationManager.notify(i4, a2);
+    }
+
+    public final void zaf(Context context) {
+        new zac(this, context).sendEmptyMessageDelayed(1, 120000L);
+    }
+
+    public final boolean zag(Activity activity, LifecycleFragment lifecycleFragment, int i, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        Dialog zaa2 = zaa(activity, i, zag.zad(lifecycleFragment, getErrorResolutionIntent(activity, i, "d"), 2), onCancelListener);
+        if (zaa2 == null) {
+            return false;
+        }
+        zad(activity, zaa2, GooglePlayServicesUtil.GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+
+    public final boolean zah(Context context, ConnectionResult connectionResult, int i) {
+        PendingIntent errorResolutionPendingIntent;
+        if (InstantApps.isInstantApp(context) || (errorResolutionPendingIntent = getErrorResolutionPendingIntent(context, connectionResult)) == null) {
+            return false;
+        }
+        zae(context, connectionResult.getErrorCode(), null, PendingIntent.getActivity(context, 0, GoogleApiActivity.zaa(context, errorResolutionPendingIntent, i, true), zap.zaa | 134217728));
+        return true;
+    }
+
+    public Dialog getErrorDialog(Activity activity, int i, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        return zaa(activity, i, zag.zab(activity, getErrorResolutionIntent(activity, i, "d"), i4), onCancelListener);
+    }
+
+    public PendingIntent getErrorResolutionPendingIntent(Context context, ConnectionResult connectionResult) {
+        if (connectionResult.hasResolution()) {
+            return connectionResult.getResolution();
+        }
+        return getErrorResolutionPendingIntent(context, connectionResult.getErrorCode(), 0);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @ShowFirstParty
+    @KeepForSdk
+    public int isGooglePlayServicesAvailable(Context context, int i) {
+        return super.isGooglePlayServicesAvailable(context, i);
+    }
+
+    public boolean showErrorDialogFragment(Activity activity, int i, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        Dialog errorDialog = getErrorDialog(activity, i, i4, onCancelListener);
+        if (errorDialog == null) {
+            return false;
+        }
+        zad(activity, errorDialog, GooglePlayServicesUtil.GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+
+    public Task<Void> checkApiAvailability(HasApiKey<?> hasApiKey, HasApiKey<?>... hasApiKeyArr) {
+        return zai(hasApiKey, hasApiKeyArr).onSuccessTask(new SuccessContinuation() { // from class: com.google.android.gms.common.zaa
+            @Override // com.google.android.gms.tasks.SuccessContinuation
+            public final Task then(Object obj) {
+                int i = GoogleApiAvailability.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+                return Tasks.forResult(null);
+            }
+        });
+    }
+
+    public void showErrorNotification(Context context, ConnectionResult connectionResult) {
+        zae(context, connectionResult.getErrorCode(), null, getErrorResolutionPendingIntent(context, connectionResult));
+    }
+
+    public Dialog getErrorDialog(K k4, int i, int i4) {
+        return getErrorDialog(k4, i, i4, (DialogInterface.OnCancelListener) null);
+    }
+
+    public Dialog getErrorDialog(K k4, int i, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        return zaa(k4.requireContext(), i, zag.zac(k4, getErrorResolutionIntent(k4.requireContext(), i, "d"), i4), onCancelListener);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GoogleApiAvailabilityLight.java

@@ -0,0 +1,161 @@
+package com.google.android.gms.common;
+
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.text.TextUtils;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.HideFirstParty;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.util.DeviceProperties;
+import com.google.android.gms.common.wrappers.Wrappers;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class GoogleApiAvailabilityLight {
+
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
+
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_STORE_PACKAGE = "com.android.vending";
+
+    @KeepForSdk
+    static final String TRACKING_SOURCE_DIALOG = "d";
+
+    @KeepForSdk
+    static final String TRACKING_SOURCE_NOTIFICATION = "n";
+
+    @KeepForSdk
+    public static final int GOOGLE_PLAY_SERVICES_VERSION_CODE = GooglePlayServicesUtilLight.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+    private static final GoogleApiAvailabilityLight zza = new GoogleApiAvailabilityLight();
+
+    @KeepForSdk
+    public GoogleApiAvailabilityLight() {
+    }
+
+    @KeepForSdk
+    public static GoogleApiAvailabilityLight getInstance() {
+        return zza;
+    }
+
+    @KeepForSdk
+    public void cancelAvailabilityErrorNotifications(Context context) {
+        GooglePlayServicesUtilLight.cancelAvailabilityErrorNotifications(context);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public int getApkVersion(Context context) {
+        return GooglePlayServicesUtilLight.getApkVersion(context);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public int getClientVersion(Context context) {
+        return GooglePlayServicesUtilLight.getClientVersion(context);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public Intent getErrorResolutionIntent(int i) {
+        return getErrorResolutionIntent(null, i, null);
+    }
+
+    @KeepForSdk
+    public PendingIntent getErrorResolutionPendingIntent(Context context, int i, int i4) {
+        return getErrorResolutionPendingIntent(context, i, i4, null);
+    }
+
+    @KeepForSdk
+    public String getErrorString(int i) {
+        return GooglePlayServicesUtilLight.getErrorString(i);
+    }
+
+    @HideFirstParty
+    @KeepForSdk
+    public int isGooglePlayServicesAvailable(Context context) {
+        return isGooglePlayServicesAvailable(context, GOOGLE_PLAY_SERVICES_VERSION_CODE);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public boolean isPlayServicesPossiblyUpdating(Context context, int i) {
+        return GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(context, i);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public boolean isPlayStorePossiblyUpdating(Context context, int i) {
+        return GooglePlayServicesUtilLight.isPlayStorePossiblyUpdating(context, i);
+    }
+
+    @KeepForSdk
+    public boolean isUninstalledAppPossiblyUpdating(Context context, String str) {
+        return GooglePlayServicesUtilLight.zza(context, str);
+    }
+
+    @KeepForSdk
+    public boolean isUserResolvableError(int i) {
+        return GooglePlayServicesUtilLight.isUserRecoverableError(i);
+    }
+
+    @KeepForSdk
+    public void verifyGooglePlayServicesIsAvailable(Context context, int i) throws GooglePlayServicesRepairableException, GooglePlayServicesNotAvailableException {
+        GooglePlayServicesUtilLight.ensurePlayServicesAvailable(context, i);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public Intent getErrorResolutionIntent(Context context, int i, String str) {
+        if (i != 1 && i != 2) {
+            if (i != 3) {
+                return null;
+            }
+            return com.google.android.gms.common.internal.zzt.zzc("com.google.android.gms");
+        }
+        if (context != null && DeviceProperties.isWearableWithoutPlayStore(context)) {
+            return com.google.android.gms.common.internal.zzt.zza();
+        }
+        StringBuilder sb = new StringBuilder("gcore_");
+        sb.append(GOOGLE_PLAY_SERVICES_VERSION_CODE);
+        sb.append("-");
+        if (!TextUtils.isEmpty(str)) {
+            sb.append(str);
+        }
+        sb.append("-");
+        if (context != null) {
+            sb.append(context.getPackageName());
+        }
+        sb.append("-");
+        if (context != null) {
+            try {
+                sb.append(Wrappers.packageManager(context).getPackageInfo(context.getPackageName(), 0).versionCode);
+            } catch (PackageManager.NameNotFoundException unused) {
+            }
+        }
+        return com.google.android.gms.common.internal.zzt.zzb("com.google.android.gms", sb.toString());
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public PendingIntent getErrorResolutionPendingIntent(Context context, int i, int i4, String str) {
+        Intent errorResolutionIntent = getErrorResolutionIntent(context, i, str);
+        if (errorResolutionIntent == null) {
+            return null;
+        }
+        return PendingIntent.getActivity(context, i4, errorResolutionIntent, com.google.android.gms.internal.common.zzd.zza | 134217728);
+    }
+
+    @KeepForSdk
+    public int isGooglePlayServicesAvailable(Context context, int i) {
+        int isGooglePlayServicesAvailable = GooglePlayServicesUtilLight.isGooglePlayServicesAvailable(context, i);
+        if (GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(context, isGooglePlayServicesAvailable)) {
+            return 18;
+        }
+        return isGooglePlayServicesAvailable;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesIncorrectManifestValueException.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepName;
+
+@KeepName
+/* loaded from: classes3.dex */
+public final class GooglePlayServicesIncorrectManifestValueException extends GooglePlayServicesManifestException {
+    public GooglePlayServicesIncorrectManifestValueException(int i) {
+        super(i, "The meta-data tag in your app's AndroidManifest.xml does not have the right value.  Expected " + GoogleApiAvailabilityLight.GOOGLE_PLAY_SERVICES_VERSION_CODE + " but found " + i + ".  You must have the following declaration within the <application> element:     <meta-data android:name=\"com.google.android.gms.version\" android:value=\"@integer/google_play_services_version\" />");
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesManifestException.java

@@ -0,0 +1,22 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepName;
+
+@KeepName
+/* loaded from: classes3.dex */
+public class GooglePlayServicesManifestException extends IllegalStateException {
+    private final int zza;
+
+    public GooglePlayServicesManifestException(int i, String str) {
+        super(str);
+        this.zza = i;
+    }
+
+    public int getActualVersion() {
+        return this.zza;
+    }
+
+    public int getExpectedVersion() {
+        return GoogleApiAvailabilityLight.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesMissingManifestValueException.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepName;
+
+@KeepName
+/* loaded from: classes3.dex */
+public final class GooglePlayServicesMissingManifestValueException extends GooglePlayServicesManifestException {
+    public GooglePlayServicesMissingManifestValueException() {
+        super(0, "A required meta-data tag in your app's AndroidManifest.xml does not exist.  You must have the following declaration within the <application> element:     <meta-data android:name=\"com.google.android.gms.version\" android:value=\"@integer/google_play_services_version\" />");
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesNotAvailableException.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common;
+
+/* loaded from: classes3.dex */
+public final class GooglePlayServicesNotAvailableException extends Exception {
+    public final int errorCode;
+
+    public GooglePlayServicesNotAvailableException(int i) {
+        this.errorCode = i;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesRepairableException.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common;
+
+import android.content.Intent;
+
+/* loaded from: classes3.dex */
+public class GooglePlayServicesRepairableException extends UserRecoverableException {
+    private final int zza;
+
+    public GooglePlayServicesRepairableException(int i, String str, Intent intent) {
+        super(str, intent);
+        this.zza = i;
+    }
+
+    public int getConnectionStatusCode() {
+        return this.zza;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesUtil.java

@@ -0,0 +1,113 @@
+package com.google.android.gms.common;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.res.Resources;
+import androidx.fragment.app.K;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.HideFirstParty;
+import com.google.android.gms.common.internal.zag;
+import com.google.android.gms.common.util.VisibleForTesting;
+
+/* loaded from: classes3.dex */
+public final class GooglePlayServicesUtil extends GooglePlayServicesUtilLight {
+    public static final String GMS_ERROR_DIALOG = "GooglePlayServicesErrorDialog";
+
+    @Deprecated
+    public static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
+
+    @Deprecated
+    public static final int GOOGLE_PLAY_SERVICES_VERSION_CODE = GooglePlayServicesUtilLight.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+    public static final String GOOGLE_PLAY_STORE_PACKAGE = "com.android.vending";
+
+    private GooglePlayServicesUtil() {
+    }
+
+    @Deprecated
+    public static Dialog getErrorDialog(int i, Activity activity, int i4) {
+        return getErrorDialog(i, activity, i4, null);
+    }
+
+    @Deprecated
+    public static PendingIntent getErrorPendingIntent(int i, Context context, int i4) {
+        return GooglePlayServicesUtilLight.getErrorPendingIntent(i, context, i4);
+    }
+
+    @VisibleForTesting
+    @Deprecated
+    public static String getErrorString(int i) {
+        return GooglePlayServicesUtilLight.getErrorString(i);
+    }
+
+    public static Context getRemoteContext(Context context) {
+        return GooglePlayServicesUtilLight.getRemoteContext(context);
+    }
+
+    public static Resources getRemoteResource(Context context) {
+        return GooglePlayServicesUtilLight.getRemoteResource(context);
+    }
+
+    @HideFirstParty
+    @Deprecated
+    public static int isGooglePlayServicesAvailable(Context context) {
+        return GooglePlayServicesUtilLight.isGooglePlayServicesAvailable(context);
+    }
+
+    @Deprecated
+    public static boolean isUserRecoverableError(int i) {
+        return GooglePlayServicesUtilLight.isUserRecoverableError(i);
+    }
+
+    @Deprecated
+    public static boolean showErrorDialogFragment(int i, Activity activity, int i4) {
+        return showErrorDialogFragment(i, activity, i4, null);
+    }
+
+    @Deprecated
+    public static void showErrorNotification(int i, Context context) {
+        GoogleApiAvailability googleApiAvailability = GoogleApiAvailability.getInstance();
+        if (GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(context, i) || GooglePlayServicesUtilLight.isPlayStorePossiblyUpdating(context, i)) {
+            googleApiAvailability.zaf(context);
+        } else {
+            googleApiAvailability.showErrorNotification(context, i);
+        }
+    }
+
+    @Deprecated
+    public static Dialog getErrorDialog(int i, Activity activity, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        if (true == GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(activity, i)) {
+            i = 18;
+        }
+        return GoogleApiAvailability.getInstance().getErrorDialog(activity, i, i4, onCancelListener);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static int isGooglePlayServicesAvailable(Context context, int i) {
+        return GooglePlayServicesUtilLight.isGooglePlayServicesAvailable(context, i);
+    }
+
+    @Deprecated
+    public static boolean showErrorDialogFragment(int i, Activity activity, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        return showErrorDialogFragment(i, activity, null, i4, onCancelListener);
+    }
+
+    public static boolean showErrorDialogFragment(int i, Activity activity, K k4, int i4, DialogInterface.OnCancelListener onCancelListener) {
+        if (true == GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(activity, i)) {
+            i = 18;
+        }
+        GoogleApiAvailability googleApiAvailability = GoogleApiAvailability.getInstance();
+        if (k4 == null) {
+            return googleApiAvailability.showErrorDialogFragment(activity, i, i4, onCancelListener);
+        }
+        Dialog zaa = googleApiAvailability.zaa(activity, i, zag.zac(k4, GoogleApiAvailability.getInstance().getErrorResolutionIntent(activity, i, "d"), i4), onCancelListener);
+        if (zaa == null) {
+            return false;
+        }
+        googleApiAvailability.zad(activity, zaa, GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GooglePlayServicesUtilLight.java

@@ -0,0 +1,348 @@
+package com.google.android.gms.common;
+
+import android.annotation.TargetApi;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageInstaller;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.os.UserManager;
+import android.util.Log;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.HideFirstParty;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.internal.zzag;
+import com.google.android.gms.common.util.ClientLibraryUtils;
+import com.google.android.gms.common.util.DeviceProperties;
+import com.google.android.gms.common.util.PlatformVersion;
+import com.google.android.gms.common.util.UidVerifier;
+import com.google.android.gms.common.util.VisibleForTesting;
+import com.google.android.gms.common.wrappers.Wrappers;
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class GooglePlayServicesUtilLight {
+
+    @KeepForSdk
+    static final int GMS_AVAILABILITY_NOTIFICATION_ID = 10436;
+
+    @KeepForSdk
+    static final int GMS_GENERAL_ERROR_NOTIFICATION_ID = 39789;
+
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_GAMES_PACKAGE = "com.google.android.play.games";
+
+    @KeepForSdk
+    @Deprecated
+    public static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
+
+    @KeepForSdk
+    @Deprecated
+    public static final int GOOGLE_PLAY_SERVICES_VERSION_CODE = 12451000;
+
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_STORE_PACKAGE = "com.android.vending";
+
+    @VisibleForTesting
+    static boolean zza = false;
+    private static boolean zzb = false;
+
+    @VisibleForTesting
+    @KeepForSdk
+    static final AtomicBoolean sCanceledAvailabilityNotification = new AtomicBoolean();
+    private static final AtomicBoolean zzc = new AtomicBoolean();
+
+    @KeepForSdk
+    public GooglePlayServicesUtilLight() {
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static void cancelAvailabilityErrorNotifications(Context context) {
+        if (!sCanceledAvailabilityNotification.getAndSet(true)) {
+            try {
+                NotificationManager notificationManager = (NotificationManager) context.getSystemService("notification");
+                if (notificationManager == null) {
+                } else {
+                    notificationManager.cancel(GMS_AVAILABILITY_NOTIFICATION_ID);
+                }
+            } catch (SecurityException unused) {
+            }
+        }
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static void enableUsingApkIndependentContext() {
+        zzc.set(true);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static void ensurePlayServicesAvailable(Context context, int i) throws GooglePlayServicesRepairableException, GooglePlayServicesNotAvailableException {
+        int isGooglePlayServicesAvailable = GoogleApiAvailabilityLight.getInstance().isGooglePlayServicesAvailable(context, i);
+        if (isGooglePlayServicesAvailable != 0) {
+            Intent errorResolutionIntent = GoogleApiAvailabilityLight.getInstance().getErrorResolutionIntent(context, isGooglePlayServicesAvailable, "e");
+            Log.e("GooglePlayServicesUtil", "GooglePlayServices not available due to error " + isGooglePlayServicesAvailable);
+            if (errorResolutionIntent != null) {
+                throw new GooglePlayServicesRepairableException(isGooglePlayServicesAvailable, "Google Play Services not available", errorResolutionIntent);
+            }
+            throw new GooglePlayServicesNotAvailableException(isGooglePlayServicesAvailable);
+        }
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static int getApkVersion(Context context) {
+        try {
+            return context.getPackageManager().getPackageInfo("com.google.android.gms", 0).versionCode;
+        } catch (PackageManager.NameNotFoundException unused) {
+            Log.w("GooglePlayServicesUtil", "Google Play services is missing.");
+            return 0;
+        }
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static int getClientVersion(Context context) {
+        Preconditions.checkState(true);
+        return ClientLibraryUtils.getClientVersion(context, context.getPackageName());
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static PendingIntent getErrorPendingIntent(int i, Context context, int i4) {
+        return GoogleApiAvailabilityLight.getInstance().getErrorResolutionPendingIntent(context, i, i4);
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    @Deprecated
+    public static String getErrorString(int i) {
+        return ConnectionResult.zza(i);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static Intent getGooglePlayServicesAvailabilityRecoveryIntent(int i) {
+        return GoogleApiAvailabilityLight.getInstance().getErrorResolutionIntent(null, i, null);
+    }
+
+    @KeepForSdk
+    public static Context getRemoteContext(Context context) {
+        try {
+            return context.createPackageContext("com.google.android.gms", 3);
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+
+    @KeepForSdk
+    public static Resources getRemoteResource(Context context) {
+        try {
+            return context.getPackageManager().getResourcesForApplication("com.google.android.gms");
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static boolean honorsDebugCertificates(Context context) {
+        try {
+            if (!zza) {
+                try {
+                    PackageInfo packageInfo = Wrappers.packageManager(context).getPackageInfo("com.google.android.gms", 64);
+                    GoogleSignatureVerifier.getInstance(context);
+                    if (packageInfo == null || GoogleSignatureVerifier.zzb(packageInfo, false) || !GoogleSignatureVerifier.zzb(packageInfo, true)) {
+                        zzb = false;
+                    } else {
+                        zzb = true;
+                    }
+                    zza = true;
+                } catch (PackageManager.NameNotFoundException e4) {
+                    Log.w("GooglePlayServicesUtil", "Cannot find Google Play services package name.", e4);
+                    zza = true;
+                }
+            }
+            return zzb || !DeviceProperties.isUserBuild();
+        } catch (Throwable th) {
+            zza = true;
+            throw th;
+        }
+    }
+
+    @HideFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static int isGooglePlayServicesAvailable(Context context) {
+        return isGooglePlayServicesAvailable(context, GOOGLE_PLAY_SERVICES_VERSION_CODE);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static boolean isGooglePlayServicesUid(Context context, int i) {
+        return UidVerifier.isGooglePlayServicesUid(context, i);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static boolean isPlayServicesPossiblyUpdating(Context context, int i) {
+        if (i == 18) {
+            return true;
+        }
+        if (i == 1) {
+            return zza(context, "com.google.android.gms");
+        }
+        return false;
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static boolean isPlayStorePossiblyUpdating(Context context, int i) {
+        if (i == 9) {
+            return zza(context, "com.android.vending");
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    @TargetApi(18)
+    public static boolean isRestrictedUserProfile(Context context) {
+        if (!PlatformVersion.isAtLeastJellyBeanMR2()) {
+            return false;
+        }
+        Object systemService = context.getSystemService("user");
+        Preconditions.checkNotNull(systemService);
+        Bundle applicationRestrictions = ((UserManager) systemService).getApplicationRestrictions(context.getPackageName());
+        return applicationRestrictions != null && "true".equals(applicationRestrictions.getString("restricted_profile"));
+    }
+
+    @VisibleForTesting
+    @Deprecated
+    @ShowFirstParty
+    @KeepForSdk
+    public static boolean isSidewinderDevice(Context context) {
+        return DeviceProperties.isSidewinder(context);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static boolean isUserRecoverableError(int i) {
+        return i == 1 || i == 2 || i == 3 || i == 9;
+    }
+
+    @KeepForSdk
+    @TargetApi(19)
+    @Deprecated
+    public static boolean uidHasPackageName(Context context, int i, String str) {
+        return UidVerifier.uidHasPackageName(context, i, str);
+    }
+
+    @TargetApi(21)
+    public static boolean zza(Context context, String str) {
+        ApplicationInfo applicationInfo;
+        boolean equals = str.equals("com.google.android.gms");
+        if (PlatformVersion.isAtLeastLollipop()) {
+            try {
+                Iterator<PackageInstaller.SessionInfo> it = context.getPackageManager().getPackageInstaller().getAllSessions().iterator();
+                while (it.hasNext()) {
+                    if (str.equals(it.next().getAppPackageName())) {
+                        return true;
+                    }
+                }
+            } catch (Exception unused) {
+                return false;
+            }
+        }
+        try {
+            applicationInfo = context.getPackageManager().getApplicationInfo(str, 8192);
+        } catch (PackageManager.NameNotFoundException unused2) {
+        }
+        return equals ? applicationInfo.enabled : applicationInfo.enabled && !isRestrictedUserProfile(context);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static int isGooglePlayServicesAvailable(Context context, int i) {
+        PackageInfo packageInfo;
+        try {
+            context.getResources().getString(R.string.common_google_play_services_unknown_issue);
+        } catch (Throwable unused) {
+            Log.e("GooglePlayServicesUtil", "The Google Play services resources were not found. Check your project configuration to ensure that the resources are included.");
+        }
+        if (!"com.google.android.gms".equals(context.getPackageName()) && !zzc.get()) {
+            int zza2 = zzag.zza(context);
+            if (zza2 != 0) {
+                if (zza2 != GOOGLE_PLAY_SERVICES_VERSION_CODE) {
+                    throw new GooglePlayServicesIncorrectManifestValueException(zza2);
+                }
+            } else {
+                throw new GooglePlayServicesMissingManifestValueException();
+            }
+        }
+        boolean z3 = (DeviceProperties.isWearableWithoutPlayStore(context) || DeviceProperties.zzb(context)) ? false : true;
+        Preconditions.checkArgument(i >= 0);
+        String packageName = context.getPackageName();
+        PackageManager packageManager = context.getPackageManager();
+        if (z3) {
+            try {
+                packageInfo = packageManager.getPackageInfo("com.android.vending", 8256);
+            } catch (PackageManager.NameNotFoundException unused2) {
+                Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires the Google Play Store, but it is missing."));
+            }
+        } else {
+            packageInfo = null;
+        }
+        try {
+            PackageInfo packageInfo2 = packageManager.getPackageInfo("com.google.android.gms", 64);
+            GoogleSignatureVerifier.getInstance(context);
+            if (!GoogleSignatureVerifier.zzb(packageInfo2, true)) {
+                Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play services, but their signature is invalid."));
+            } else {
+                if (z3) {
+                    Preconditions.checkNotNull(packageInfo);
+                    if (!GoogleSignatureVerifier.zzb(packageInfo, true)) {
+                        Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play Store, but its signature is invalid."));
+                    }
+                }
+                if (z3 && packageInfo != null && !packageInfo.signatures[0].equals(packageInfo2.signatures[0])) {
+                    Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play Store, but its signature doesn't match that of Google Play services."));
+                } else {
+                    if (com.google.android.gms.common.util.zza.zza(packageInfo2.versionCode) < com.google.android.gms.common.util.zza.zza(i)) {
+                        Log.w("GooglePlayServicesUtil", "Google Play services out of date for " + packageName + ".  Requires " + i + " but found " + packageInfo2.versionCode);
+                        return 2;
+                    }
+                    ApplicationInfo applicationInfo = packageInfo2.applicationInfo;
+                    if (applicationInfo == null) {
+                        try {
+                            applicationInfo = packageManager.getApplicationInfo("com.google.android.gms", 0);
+                        } catch (PackageManager.NameNotFoundException e4) {
+                            Log.wtf("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play services, but they're missing when getting application info."), e4);
+                            return 1;
+                        }
+                    }
+                    return !applicationInfo.enabled ? 3 : 0;
+                }
+            }
+            return 9;
+        } catch (PackageManager.NameNotFoundException unused3) {
+            Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play services, but they are missing."));
+            return 1;
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GoogleSignatureVerifier.java

@@ -0,0 +1,167 @@
+package com.google.android.gms.common;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.Signature;
+import android.util.Log;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.errorprone.annotations.RestrictedInheritance;
+import java.util.Set;
+
+@ShowFirstParty
+@KeepForSdk
+@RestrictedInheritance(allowedOnPath = ".*java.*/com/google/android/gms/common/testing/.*", explanation = "Sub classing of GMS Core's APIs are restricted to testing fakes.", link = "go/gmscore-restrictedinheritance")
+/* loaded from: classes3.dex */
+public class GoogleSignatureVerifier {
+    private static GoogleSignatureVerifier zza;
+    private static volatile Set zzb;
+    private final Context zzc;
+    private volatile String zzd;
+
+    public GoogleSignatureVerifier(Context context) {
+        this.zzc = context.getApplicationContext();
+    }
+
+    @KeepForSdk
+    public static GoogleSignatureVerifier getInstance(Context context) {
+        Preconditions.checkNotNull(context);
+        synchronized (GoogleSignatureVerifier.class) {
+            try {
+                if (zza == null) {
+                    zzn.zze(context);
+                    zza = new GoogleSignatureVerifier(context);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zza;
+    }
+
+    public static final zzj zza(PackageInfo packageInfo, zzj... zzjVarArr) {
+        Signature[] signatureArr = packageInfo.signatures;
+        if (signatureArr == null) {
+            return null;
+        }
+        if (signatureArr.length != 1) {
+            Log.w("GoogleSignatureVerifier", "Package has more than one signature.");
+            return null;
+        }
+        zzk zzkVar = new zzk(packageInfo.signatures[0].toByteArray());
+        for (int i = 0; i < zzjVarArr.length; i++) {
+            if (zzjVarArr[i].equals(zzkVar)) {
+                return zzjVarArr[i];
+            }
+        }
+        return null;
+    }
+
+    public static final boolean zzb(PackageInfo packageInfo, boolean z3) {
+        if (z3 && packageInfo != null && ("com.android.vending".equals(packageInfo.packageName) || "com.google.android.gms".equals(packageInfo.packageName))) {
+            ApplicationInfo applicationInfo = packageInfo.applicationInfo;
+            z3 = (applicationInfo == null || (applicationInfo.flags & 129) == 0) ? false : true;
+        }
+        if (packageInfo != null && packageInfo.signatures != null) {
+            if ((z3 ? zza(packageInfo, zzm.zza) : zza(packageInfo, zzm.zza[0])) != null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @SuppressLint({"PackageManagerGetSignatures"})
+    private final zzx zzc(String str, boolean z3, boolean z4) {
+        zzx zzc;
+        ApplicationInfo applicationInfo;
+        if (str == null) {
+            return zzx.zzc("null pkg");
+        }
+        if (str.equals(this.zzd)) {
+            return zzx.zzb();
+        }
+        if (zzn.zzg()) {
+            zzc = zzn.zzb(str, GooglePlayServicesUtilLight.honorsDebugCertificates(this.zzc), false, false);
+        } else {
+            try {
+                PackageInfo packageInfo = this.zzc.getPackageManager().getPackageInfo(str, 64);
+                boolean honorsDebugCertificates = GooglePlayServicesUtilLight.honorsDebugCertificates(this.zzc);
+                if (packageInfo == null) {
+                    zzc = zzx.zzc("null pkg");
+                } else {
+                    Signature[] signatureArr = packageInfo.signatures;
+                    if (signatureArr == null || signatureArr.length != 1) {
+                        zzc = zzx.zzc("single cert required");
+                    } else {
+                        zzk zzkVar = new zzk(packageInfo.signatures[0].toByteArray());
+                        String str2 = packageInfo.packageName;
+                        zzx zza2 = zzn.zza(str2, zzkVar, honorsDebugCertificates, false);
+                        zzc = (!zza2.zza || (applicationInfo = packageInfo.applicationInfo) == null || (applicationInfo.flags & 2) == 0 || !zzn.zza(str2, zzkVar, false, true).zza) ? zza2 : zzx.zzc("debuggable release cert app rejected");
+                    }
+                }
+            } catch (PackageManager.NameNotFoundException e4) {
+                return zzx.zzd("no pkg ".concat(str), e4);
+            }
+        }
+        if (zzc.zza) {
+            this.zzd = str;
+        }
+        return zzc;
+    }
+
+    @KeepForSdk
+    public boolean isGooglePublicSignedPackage(PackageInfo packageInfo) {
+        if (packageInfo == null) {
+            return false;
+        }
+        if (zzb(packageInfo, false)) {
+            return true;
+        }
+        if (zzb(packageInfo, true)) {
+            if (GooglePlayServicesUtilLight.honorsDebugCertificates(this.zzc)) {
+                return true;
+            }
+            Log.w("GoogleSignatureVerifier", "Test-keys aren't accepted on this build.");
+        }
+        return false;
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public boolean isPackageGoogleSigned(String str) {
+        zzx zzc = zzc(str, false, false);
+        zzc.zze();
+        return zzc.zza;
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public boolean isUidGoogleSigned(int i) {
+        zzx zzc;
+        int length;
+        String[] packagesForUid = this.zzc.getPackageManager().getPackagesForUid(i);
+        if (packagesForUid != null && (length = packagesForUid.length) != 0) {
+            zzc = null;
+            int i4 = 0;
+            while (true) {
+                if (i4 >= length) {
+                    Preconditions.checkNotNull(zzc);
+                    break;
+                }
+                zzc = zzc(packagesForUid[i4], false, false);
+                if (zzc.zza) {
+                    break;
+                }
+                i4++;
+            }
+        } else {
+            zzc = zzx.zzc("no pkgs");
+        }
+        zzc.zze();
+        return zzc.zza;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/GoogleSourceStampsChecker.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class GoogleSourceStampsChecker {
+}

apk_decompiled/sources/com/google/android/gms/common/GoogleSourceStampsResult.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes3.dex */
+public final class GoogleSourceStampsResult {
+}

apk_decompiled/sources/com/google/android/gms/common/PackageSignatureVerifier.java

@@ -0,0 +1,78 @@
+package com.google.android.gms.common;
+
+import android.content.Context;
+import android.util.Log;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.errorprone.annotations.RestrictedInheritance;
+
+@ShowFirstParty
+@KeepForSdk
+@RestrictedInheritance(allowedOnPath = ".*javatests.*/com/google/android/gms/common/.*", explanation = "Sub classing of GMS Core's APIs are restricted to testing fakes.", link = "go/gmscore-restrictedinheritance")
+/* loaded from: classes3.dex */
+public class PackageSignatureVerifier {
+    private static zzad zza;
+    private volatile zzac zzb;
+
+    private static zzad zza() {
+        zzad zzadVar;
+        synchronized (zzad.class) {
+            try {
+                if (zza == null) {
+                    zza = new zzad();
+                }
+                zzadVar = zza;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zzadVar;
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public PackageVerificationResult queryPackageSignatureVerified(Context context, String str) {
+        PackageVerificationResult packageVerificationResult;
+        String str2;
+        PackageVerificationResult packageVerificationResult2;
+        boolean honorsDebugCertificates = GooglePlayServicesUtilLight.honorsDebugCertificates(context);
+        zza();
+        if (!zzn.zzf()) {
+            throw new zzae();
+        }
+        String concat = String.valueOf(str).concat(true != honorsDebugCertificates ? "-0" : "-1");
+        if (this.zzb != null) {
+            str2 = this.zzb.zza;
+            if (str2.equals(concat)) {
+                packageVerificationResult2 = this.zzb.zzb;
+                return packageVerificationResult2;
+            }
+        }
+        zza();
+        zzx zzc = zzn.zzc(str, honorsDebugCertificates, false, false);
+        if (!zzc.zza) {
+            Preconditions.checkNotNull(zzc.zzb);
+            return PackageVerificationResult.zza(str, zzc.zzb, zzc.zzc);
+        }
+        this.zzb = new zzac(concat, PackageVerificationResult.zzd(str, zzc.zzd));
+        packageVerificationResult = this.zzb.zzb;
+        return packageVerificationResult;
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public PackageVerificationResult queryPackageSignatureVerifiedWithRetry(Context context, String str) {
+        try {
+            PackageVerificationResult queryPackageSignatureVerified = queryPackageSignatureVerified(context, str);
+            queryPackageSignatureVerified.zzb();
+            return queryPackageSignatureVerified;
+        } catch (SecurityException e4) {
+            PackageVerificationResult queryPackageSignatureVerified2 = queryPackageSignatureVerified(context, str);
+            if (queryPackageSignatureVerified2.zzc()) {
+                Log.e("PkgSignatureVerifier", "Got flaky result during package signature verification", e4);
+            }
+            return queryPackageSignatureVerified2;
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/PackageVerificationResult.java

@@ -0,0 +1,40 @@
+package com.google.android.gms.common;
+
+/* loaded from: classes3.dex */
+public class PackageVerificationResult {
+    private final String zza;
+    private final boolean zzb;
+    private final String zzc;
+    private final Throwable zzd;
+
+    private PackageVerificationResult(String str, int i, boolean z3, String str2, Throwable th) {
+        this.zza = str;
+        this.zzb = z3;
+        this.zzc = str2;
+        this.zzd = th;
+    }
+
+    public static PackageVerificationResult zza(String str, String str2, Throwable th) {
+        return new PackageVerificationResult(str, 1, false, str2, th);
+    }
+
+    public static PackageVerificationResult zzd(String str, int i) {
+        return new PackageVerificationResult(str, i, true, null, null);
+    }
+
+    public final void zzb() {
+        if (this.zzb) {
+            return;
+        }
+        String concat = "PackageVerificationRslt: ".concat(String.valueOf(this.zzc));
+        Throwable th = this.zzd;
+        if (th == null) {
+            throw new SecurityException(concat);
+        }
+        throw new SecurityException(concat, th);
+    }
+
+    public final boolean zzc() {
+        return this.zzb;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/ProGuardCanary.java

@@ -0,0 +1,14 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes3.dex */
+final class ProGuardCanary {
+
+    @KeepForSdk
+    static final String CANARY = "gms_proguard_canary";
+
+    private ProGuardCanary() {
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/R.java

@@ -0,0 +1,24 @@
+package com.google.android.gms.common;
+
+/* loaded from: classes3.dex */
+public final class R {
+
+    /* loaded from: classes3.dex */
+    public static final class integer {
+        public static final int google_play_services_version = 0x7f0a0009;
+
+        private integer() {
+        }
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class string {
+        public static final int common_google_play_services_unknown_issue = 0x7f1300bc;
+
+        private string() {
+        }
+    }
+
+    private R() {
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/Scopes.java

@@ -0,0 +1,39 @@
+package com.google.android.gms.common;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+/* loaded from: classes3.dex */
+public final class Scopes {
+    public static final String APP_STATE = "https://www.googleapis.com/auth/appstate";
+    public static final String CLOUD_SAVE = "https://www.googleapis.com/auth/datastoremobile";
+    public static final String DRIVE_APPFOLDER = "https://www.googleapis.com/auth/drive.appdata";
+
+    @KeepForSdk
+    public static final String DRIVE_APPS = "https://www.googleapis.com/auth/drive.apps";
+    public static final String DRIVE_FILE = "https://www.googleapis.com/auth/drive.file";
+
+    @KeepForSdk
+    public static final String DRIVE_FULL = "https://www.googleapis.com/auth/drive";
+    public static final String EMAIL = "email";
+    public static final String GAMES = "https://www.googleapis.com/auth/games";
+
+    @KeepForSdk
+    public static final String GAMES_LITE = "https://www.googleapis.com/auth/games_lite";
+
+    @KeepForSdk
+    public static final String LEGACY_USERINFO_EMAIL = "https://www.googleapis.com/auth/userinfo.email";
+
+    @KeepForSdk
+    public static final String LEGACY_USERINFO_PROFILE = "https://www.googleapis.com/auth/userinfo.profile";
+
+    @KeepForSdk
+    public static final String OPEN_ID = "openid";
+
+    @Deprecated
+    public static final String PLUS_LOGIN = "https://www.googleapis.com/auth/plus.login";
+    public static final String PLUS_ME = "https://www.googleapis.com/auth/plus.me";
+    public static final String PROFILE = "profile";
+
+    private Scopes() {
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/SignInButton.java

@@ -0,0 +1,129 @@
+package com.google.android.gms.common;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import android.widget.FrameLayout;
+import com.google.android.gms.common.api.Scope;
+import com.google.android.gms.common.internal.zaaa;
+import com.google.android.gms.common.internal.zaz;
+import com.google.android.gms.dynamic.RemoteCreator;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes3.dex */
+public final class SignInButton extends FrameLayout implements View.OnClickListener {
+    public static final int COLOR_AUTO = 2;
+    public static final int COLOR_DARK = 0;
+    public static final int COLOR_LIGHT = 1;
+    public static final int SIZE_ICON_ONLY = 2;
+    public static final int SIZE_STANDARD = 0;
+    public static final int SIZE_WIDE = 1;
+    private int zaa;
+    private int zab;
+    private View zac;
+    private View.OnClickListener zad;
+
+    @Retention(RetentionPolicy.SOURCE)
+    /* loaded from: classes3.dex */
+    public @interface ButtonSize {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    /* loaded from: classes3.dex */
+    public @interface ColorScheme {
+    }
+
+    public SignInButton(Context context) {
+        this(context, null);
+    }
+
+    private final void zaa(Context context) {
+        View view = this.zac;
+        if (view != null) {
+            removeView(view);
+        }
+        try {
+            this.zac = zaz.zaa(context, this.zaa, this.zab);
+        } catch (RemoteCreator.RemoteCreatorException unused) {
+            Log.w("SignInButton", "Sign in button not found, using placeholder instead");
+            int i = this.zaa;
+            int i4 = this.zab;
+            zaaa zaaaVar = new zaaa(context, null);
+            zaaaVar.zaa(context.getResources(), i, i4);
+            this.zac = zaaaVar;
+        }
+        addView(this.zac);
+        this.zac.setEnabled(isEnabled());
+        this.zac.setOnClickListener(this);
+    }
+
+    @Override // android.view.View.OnClickListener
+    public void onClick(View view) {
+        View.OnClickListener onClickListener = this.zad;
+        if (onClickListener == null || view != this.zac) {
+            return;
+        }
+        onClickListener.onClick(this);
+    }
+
+    public void setColorScheme(int i) {
+        setStyle(this.zaa, i);
+    }
+
+    @Override // android.view.View
+    public void setEnabled(boolean z3) {
+        super.setEnabled(z3);
+        this.zac.setEnabled(z3);
+    }
+
+    @Override // android.view.View
+    public void setOnClickListener(View.OnClickListener onClickListener) {
+        this.zad = onClickListener;
+        View view = this.zac;
+        if (view != null) {
+            view.setOnClickListener(this);
+        }
+    }
+
+    @Deprecated
+    public void setScopes(Scope[] scopeArr) {
+        setStyle(this.zaa, this.zab);
+    }
+
+    public void setSize(int i) {
+        setStyle(i, this.zab);
+    }
+
+    public void setStyle(int i, int i4) {
+        this.zaa = i;
+        this.zab = i4;
+        zaa(getContext());
+    }
+
+    public SignInButton(Context context, AttributeSet attributeSet) {
+        this(context, attributeSet, 0);
+    }
+
+    @Deprecated
+    public void setStyle(int i, int i4, Scope[] scopeArr) {
+        setStyle(i, i4);
+    }
+
+    public SignInButton(Context context, AttributeSet attributeSet, int i) {
+        super(context, attributeSet, i);
+        this.zad = null;
+        TypedArray obtainStyledAttributes = context.getTheme().obtainStyledAttributes(attributeSet, com.google.android.gms.base.R.styleable.SignInButton, 0, 0);
+        try {
+            this.zaa = obtainStyledAttributes.getInt(com.google.android.gms.base.R.styleable.SignInButton_buttonSize, 0);
+            this.zab = obtainStyledAttributes.getInt(com.google.android.gms.base.R.styleable.SignInButton_colorScheme, 2);
+            obtainStyledAttributes.recycle();
+            setStyle(this.zaa, this.zab);
+        } catch (Throwable th) {
+            obtainStyledAttributes.recycle();
+            throw th;
+        }
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/SupportErrorDialogFragment.java

@@ -0,0 +1,59 @@
+package com.google.android.gms.common;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import androidx.fragment.app.AbstractC0158l0;
+import androidx.fragment.app.DialogInterfaceOnCancelListenerC0174y;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+public class SupportErrorDialogFragment extends DialogInterfaceOnCancelListenerC0174y {
+    private Dialog zaa;
+    private DialogInterface.OnCancelListener zab;
+    private Dialog zac;
+
+    public static SupportErrorDialogFragment newInstance(Dialog dialog) {
+        return newInstance(dialog, null);
+    }
+
+    @Override // androidx.fragment.app.DialogInterfaceOnCancelListenerC0174y, android.content.DialogInterface.OnCancelListener
+    public void onCancel(DialogInterface dialogInterface) {
+        DialogInterface.OnCancelListener onCancelListener = this.zab;
+        if (onCancelListener != null) {
+            onCancelListener.onCancel(dialogInterface);
+        }
+    }
+
+    @Override // androidx.fragment.app.DialogInterfaceOnCancelListenerC0174y
+    public Dialog onCreateDialog(Bundle bundle) {
+        Dialog dialog = this.zaa;
+        if (dialog != null) {
+            return dialog;
+        }
+        setShowsDialog(false);
+        if (this.zac == null) {
+            this.zac = new AlertDialog.Builder((Context) Preconditions.checkNotNull(getContext())).create();
+        }
+        return this.zac;
+    }
+
+    @Override // androidx.fragment.app.DialogInterfaceOnCancelListenerC0174y
+    public void show(AbstractC0158l0 abstractC0158l0, String str) {
+        super.show(abstractC0158l0, str);
+    }
+
+    public static SupportErrorDialogFragment newInstance(Dialog dialog, DialogInterface.OnCancelListener onCancelListener) {
+        SupportErrorDialogFragment supportErrorDialogFragment = new SupportErrorDialogFragment();
+        Dialog dialog2 = (Dialog) Preconditions.checkNotNull(dialog, "Cannot display null dialog");
+        dialog2.setOnCancelListener(null);
+        dialog2.setOnDismissListener(null);
+        supportErrorDialogFragment.zaa = dialog2;
+        if (onCancelListener != null) {
+            supportErrorDialogFragment.zab = onCancelListener;
+        }
+        return supportErrorDialogFragment;
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/UserRecoverableException.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.common;
+
+import android.content.Intent;
+
+/* loaded from: classes3.dex */
+public class UserRecoverableException extends Exception {
+    private final Intent zza;
+
+    public UserRecoverableException(String str, Intent intent) {
+        super(str);
+        this.zza = intent;
+    }
+
+    public Intent getIntent() {
+        return new Intent(this.zza);
+    }
+}

apk_decompiled/sources/com/google/android/gms/common/annotation/KeepForSdk.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Documented
+/* loaded from: classes3.dex */
+public @interface KeepForSdk {
+}

apk_decompiled/sources/com/google/android/gms/common/annotation/KeepForSdkWithFieldsAndMethods.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.common.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Deprecated
+/* loaded from: classes3.dex */
+public @interface KeepForSdkWithFieldsAndMethods {
+}

apk_decompiled/sources/com/google/android/gms/common/annotation/KeepForSdkWithMembers.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.common.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Documented
+@Deprecated
+/* loaded from: classes3.dex */
+public @interface KeepForSdkWithMembers {
+}

apk_decompiled/sources/com/google/android/gms/common/annotation/KeepName.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
+@Documented
+/* loaded from: classes3.dex */
+public @interface KeepName {
+}

apk_decompiled/sources/com/google/android/gms/common/annotation/NonNullApi.java

@@ -0,0 +1,15 @@
+package com.google.android.gms.common.annotation;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE, ElementType.PACKAGE})
+@KeepForSdk
+@Documented
+@Retention(RetentionPolicy.CLASS)
+/* loaded from: classes3.dex */
+public @interface NonNullApi {
+}

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