Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/google/android/gms/common/AccountPicker.java

@@ -0,0 +1,242 @@
+package com.google.android.gms.common;
+
+import android.accounts.Account;
+import android.content.Intent;
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes2.dex */
+public final class AccountPicker {
+
+    public static class AccountChooserOptions {
+
+        @Nullable
+        private Account zza;
+        private boolean zzb;
+
+        @Nullable
+        private ArrayList zzc;
+
+        @Nullable
+        private ArrayList zzd;
+        private boolean zze;
+
+        @Nullable
+        private String zzf;
+
+        @Nullable
+        private Bundle zzg;
+        private boolean zzh;
+        private int zzi;
+
+        @Nullable
+        private String zzj;
+        private boolean zzk;
+
+        @Nullable
+        private zza zzl;
+
+        @Nullable
+        private String zzm;
+        private boolean zzn;
+        private boolean zzo;
+
+        public static class Builder {
+
+            @Nullable
+            private Account zza;
+
+            @Nullable
+            private ArrayList zzb;
+
+            @Nullable
+            private ArrayList zzc;
+            private boolean zzd = false;
+
+            @Nullable
+            private String zze;
+
+            @Nullable
+            private Bundle zzf;
+
+            @NonNull
+            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;
+            }
+
+            @NonNull
+            public Builder setAllowableAccounts(@Nullable List<Account> list) {
+                this.zzb = list == null ? null : new ArrayList(list);
+                return this;
+            }
+
+            @NonNull
+            public Builder setAllowableAccountsTypes(@Nullable List<String> list) {
+                this.zzc = list == null ? null : new ArrayList(list);
+                return this;
+            }
+
+            @NonNull
+            public Builder setAlwaysShowAccountPicker(boolean z) {
+                this.zzd = z;
+                return this;
+            }
+
+            @NonNull
+            public Builder setOptionsForAddingAccount(@Nullable Bundle bundle) {
+                this.zzf = bundle;
+                return this;
+            }
+
+            @NonNull
+            public Builder setSelectedAccount(@Nullable Account account) {
+                this.zza = account;
+                return this;
+            }
+
+            @NonNull
+            public Builder setTitleOverrideText(@Nullable String str) {
+                this.zze = str;
+                return this;
+            }
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzA(AccountChooserOptions accountChooserOptions) {
+            boolean z = accountChooserOptions.zzo;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzB(AccountChooserOptions accountChooserOptions) {
+            boolean z = accountChooserOptions.zzb;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzC(AccountChooserOptions accountChooserOptions) {
+            boolean z = accountChooserOptions.zzh;
+            return false;
+        }
+
+        public static /* bridge */ /* synthetic */ boolean zzD(AccountChooserOptions accountChooserOptions) {
+            boolean z = 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 z = accountChooserOptions.zzn;
+            return false;
+        }
+    }
+
+    private AccountPicker() {
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @Deprecated
+    public static Intent newChooseAccountIntent(@Nullable Account account, @Nullable ArrayList<Account> arrayList, @Nullable String[] strArr, boolean z, @Nullable String str, @Nullable String str2, @Nullable String[] strArr2, @Nullable 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", z);
+        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;
+    }
+
+    @NonNull
+    public static Intent newChooseAccountIntent(@NonNull 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_DAY_NIGHT_GOOGLE_MATERIAL2, THEME_LIGHT_GOOGLE_MATERIAL3, THEME_DARK_GOOGLE_MATERIAL3 or THEME_DAY_NIGHT_GOOGLE_MATERIAL3 themes");
+        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;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/BlockingServiceConnection.java

@@ -0,0 +1,57 @@
+package com.google.android.gms.common;
+
+import android.content.ComponentName;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class BlockingServiceConnection implements ServiceConnection {
+    boolean zza = false;
+    private final BlockingQueue zzb = new LinkedBlockingQueue();
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @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();
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public IBinder getServiceWithTimeout(long j, @NonNull 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(j, timeUnit);
+        if (iBinder != null) {
+            return iBinder;
+        }
+        throw new TimeoutException("Timed out waiting for the service connection");
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceConnected(@NonNull ComponentName componentName, @NonNull IBinder iBinder) {
+        this.zzb.add(iBinder);
+    }
+
+    @Override // android.content.ServiceConnection
+    public final void onServiceDisconnected(@NonNull ComponentName componentName) {
+    }
+}

decompiled-community/sources/com/google/android/gms/common/ConnectionResult.java

@@ -0,0 +1,224 @@
+package com.google.android.gms.common;
+
+import android.app.Activity;
+import android.app.PendingIntent;
+import android.content.IntentSender;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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: classes2.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;
+
+    @Nullable
+    @SafeParcelable.Field(getter = "getResolution", id = 3)
+    private final PendingIntent zzc;
+
+    @Nullable
+    @SafeParcelable.Field(getter = "getErrorMessage", id = 4)
+    private final String zzd;
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final ConnectionResult RESULT_SUCCESS = new ConnectionResult(0);
+
+    @NonNull
+    public static final Parcelable.Creator<ConnectionResult> CREATOR = new zzb();
+
+    public ConnectionResult(int i) {
+        this(i, null, null);
+    }
+
+    @SafeParcelable.Constructor
+    public ConnectionResult(@SafeParcelable.Param(id = 1) int i, @SafeParcelable.Param(id = 2) int i2, @Nullable @SafeParcelable.Param(id = 3) PendingIntent pendingIntent, @Nullable @SafeParcelable.Param(id = 4) String str) {
+        this.zza = i;
+        this.zzb = i2;
+        this.zzc = pendingIntent;
+        this.zzd = str;
+    }
+
+    public ConnectionResult(int i, @Nullable PendingIntent pendingIntent) {
+        this(i, pendingIntent, null);
+    }
+
+    @NonNull
+    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 "UNKNOWN_ERROR_CODE(" + i + ")";
+                }
+        }
+    }
+
+    public boolean equals(@Nullable 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;
+    }
+
+    @Nullable
+    public String getErrorMessage() {
+        return this.zzd;
+    }
+
+    @Nullable
+    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(@NonNull 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);
+        }
+    }
+
+    @NonNull
+    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(@NonNull Parcel parcel, int i) {
+        int i2 = this.zza;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        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, @Nullable PendingIntent pendingIntent, @Nullable String str) {
+        this(1, i, pendingIntent, str);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/ErrorDialogFragment.java

@@ -0,0 +1,66 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public class ErrorDialogFragment extends DialogFragment {
+    private Dialog zaa;
+    private DialogInterface.OnCancelListener zab;
+
+    @Nullable
+    private Dialog zac;
+
+    @NonNull
+    public static ErrorDialogFragment newInstance(@NonNull Dialog dialog) {
+        return newInstance(dialog, null);
+    }
+
+    @Override // android.app.DialogFragment, android.content.DialogInterface.OnCancelListener
+    public void onCancel(@NonNull DialogInterface dialogInterface) {
+        DialogInterface.OnCancelListener onCancelListener = this.zab;
+        if (onCancelListener != null) {
+            onCancelListener.onCancel(dialogInterface);
+        }
+    }
+
+    @Override // android.app.DialogFragment
+    @NonNull
+    public Dialog onCreateDialog(@Nullable 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(@NonNull FragmentManager fragmentManager, @Nullable String str) {
+        super.show(fragmentManager, str);
+    }
+
+    @NonNull
+    public static ErrorDialogFragment newInstance(@NonNull Dialog dialog, @Nullable 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;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/Feature.java

@@ -0,0 +1,88 @@
+package com.google.android.gms.common;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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.unity3d.services.ads.gmascar.bridges.mobileads.MobileAdsBridge;
+
+@KeepForSdk
+@SafeParcelable.Class(creator = "FeatureCreator")
+/* loaded from: classes2.dex */
+public class Feature extends AbstractSafeParcelable {
+
+    @NonNull
+    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 = MobileAdsBridge.versionMethodName, id = 3)
+    private final long zzc;
+
+    @SafeParcelable.Constructor
+    public Feature(@NonNull @SafeParcelable.Param(id = 1) String str, @SafeParcelable.Param(id = 2) int i, @SafeParcelable.Param(id = 3) long j) {
+        this.zza = str;
+        this.zzb = i;
+        this.zzc = j;
+    }
+
+    @KeepForSdk
+    public Feature(@NonNull String str, long j) {
+        this.zza = str;
+        this.zzc = j;
+        this.zzb = -1;
+    }
+
+    public final boolean equals(@Nullable 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;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public String getName() {
+        return this.zza;
+    }
+
+    @KeepForSdk
+    public long getVersion() {
+        long j = this.zzc;
+        return j == -1 ? this.zzb : j;
+    }
+
+    public final int hashCode() {
+        return Objects.hashCode(getName(), Long.valueOf(getVersion()));
+    }
+
+    @NonNull
+    public final String toString() {
+        Objects.ToStringHelper stringHelper = Objects.toStringHelper(this);
+        stringHelper.add("name", getName());
+        stringHelper.add("version", Long.valueOf(getVersion()));
+        return stringHelper.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(@NonNull 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);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/FirstPartyScopes.java

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

decompiled-community/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: classes2.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();
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GoogleApiAvailability.java

@@ -0,0 +1,390 @@
+package com.google.android.gms.common;
+
+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.activity.result.ActivityResultLauncher;
+import androidx.activity.result.IntentSenderRequest;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+import androidx.fragment.app.Fragment;
+import androidx.fragment.app.FragmentActivity;
+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.zae;
+import com.google.android.gms.internal.base.zao;
+import com.google.android.gms.internal.base.zap;
+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 com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import com.ironsource.nb;
+import com.unity3d.services.UnityAdsConstants;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+@RestrictedInheritance(allowedOnPath = ".*java.*/com/google/android/gms.*", allowlistAnnotations = {com.google.android.gms.internal.base.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: classes2.dex */
+public class GoogleApiAvailability extends GoogleApiAvailabilityLight {
+
+    @NonNull
+    public static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
+
+    @GuardedBy("lock")
+    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;
+
+    @NonNull
+    public static GoogleApiAvailability getInstance() {
+        return zab;
+    }
+
+    @NonNull
+    public static final Task zai(@NonNull HasApiKey hasApiKey, @NonNull 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.zaj().zam(arrayList);
+    }
+
+    @NonNull
+    public Task<Void> checkApiAvailability(@NonNull GoogleApi<?> googleApi, @NonNull 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(@NonNull Context context) {
+        return super.getClientVersion(context);
+    }
+
+    @Nullable
+    public Dialog getErrorDialog(@NonNull Activity activity, int i, int i2) {
+        return getErrorDialog(activity, i, i2, (DialogInterface.OnCancelListener) null);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @Nullable
+    @ShowFirstParty
+    @KeepForSdk
+    public Intent getErrorResolutionIntent(@Nullable Context context, int i, @Nullable String str) {
+        return super.getErrorResolutionIntent(context, i, str);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @Nullable
+    public PendingIntent getErrorResolutionPendingIntent(@NonNull Context context, int i, int i2) {
+        return super.getErrorResolutionPendingIntent(context, i, i2);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @NonNull
+    public final String getErrorString(int i) {
+        return super.getErrorString(i);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @ResultIgnorabilityUnspecified
+    @HideFirstParty
+    public int isGooglePlayServicesAvailable(@NonNull Context context) {
+        return super.isGooglePlayServicesAvailable(context);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    public final boolean isUserResolvableError(int i) {
+        return super.isUserResolvableError(i);
+    }
+
+    @NonNull
+    @MainThread
+    public Task<Void> makeGooglePlayServicesAvailable(@NonNull 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(@NonNull Context context, @NonNull String str) {
+        if (PlatformVersion.isAtLeastO()) {
+            Preconditions.checkNotNull(((NotificationManager) Preconditions.checkNotNull(context.getSystemService("notification"))).getNotificationChannel(str));
+        }
+        synchronized (zaa) {
+            this.zac = str;
+        }
+    }
+
+    @ResultIgnorabilityUnspecified
+    public boolean showErrorDialogFragment(@NonNull Activity activity, int i, int i2) {
+        return showErrorDialogFragment(activity, i, i2, (DialogInterface.OnCancelListener) null);
+    }
+
+    public void showErrorNotification(@NonNull Context context, int i) {
+        zae(context, i, null, getErrorResolutionPendingIntent(context, i, 0, nb.q));
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @Nullable
+    public final Dialog zaa(@NonNull Context context, int i, @Nullable zag zagVar, @Nullable DialogInterface.OnCancelListener onCancelListener, @Nullable DialogInterface.OnClickListener onClickListener) {
+        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.zac(context, i));
+        if (onCancelListener != null) {
+            builder.setOnCancelListener(onCancelListener);
+        }
+        String zab2 = com.google.android.gms.common.internal.zac.zab(context, i);
+        if (zab2 != null) {
+            if (zagVar == null) {
+                zagVar = onClickListener;
+            }
+            builder.setPositiveButton(zab2, zagVar);
+        }
+        String zaf = com.google.android.gms.common.internal.zac.zaf(context, i);
+        if (zaf != null) {
+            builder.setTitle(zaf);
+        }
+        Log.w("GoogleApiAvailability", String.format("Creating dialog for Google Play services availability issue. ConnectionResult=%s", Integer.valueOf(i)), new IllegalArgumentException());
+        return builder.create();
+    }
+
+    @NonNull
+    public final Dialog zab(@NonNull Activity activity, @NonNull 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.zac(activity, 18));
+        builder.setPositiveButton("", (DialogInterface.OnClickListener) null);
+        AlertDialog create = builder.create();
+        zad(activity, create, "GooglePlayServicesUpdatingDialog", onCancelListener);
+        return create;
+    }
+
+    @Nullable
+    @ResultIgnorabilityUnspecified
+    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, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        try {
+            if (activity instanceof FragmentActivity) {
+                SupportErrorDialogFragment.newInstance(dialog, onCancelListener).show(((FragmentActivity) activity).getSupportFragmentManager(), str);
+                return;
+            }
+        } catch (NoClassDefFoundError unused) {
+        }
+        ErrorDialogFragment.newInstance(dialog, onCancelListener).show(activity.getFragmentManager(), str);
+    }
+
+    @TargetApi(20)
+    public final void zae(Context context, int i, @Nullable String str, @Nullable PendingIntent pendingIntent) {
+        int i2;
+        String str2;
+        Log.w("GoogleApiAvailability", String.format("GMS core API Availability. ConnectionResult=%s, tag=%s", Integer.valueOf(i), 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 zae = com.google.android.gms.common.internal.zac.zae(context, i);
+        String zad = com.google.android.gms.common.internal.zac.zad(context, i);
+        Resources resources = context.getResources();
+        NotificationManager notificationManager = (NotificationManager) Preconditions.checkNotNull(context.getSystemService("notification"));
+        NotificationCompat.Builder style = new NotificationCompat.Builder(context).setLocalOnly(true).setAutoCancel(true).setContentTitle(zae).setStyle(new NotificationCompat.BigTextStyle().bigText(zad));
+        if (DeviceProperties.isWearable(context)) {
+            Preconditions.checkState(PlatformVersion.isAtLeastKitKatWatch());
+            style.setSmallIcon(context.getApplicationInfo().icon).setPriority(2);
+            if (DeviceProperties.isWearableWithoutPlayStore(context)) {
+                style.addAction(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 {
+                style.setContentIntent(pendingIntent);
+            }
+        } else {
+            style.setSmallIcon(android.R.drawable.stat_sys_warning).setTicker(resources.getString(com.google.android.gms.base.R.string.common_google_play_services_notification_ticker)).setWhen(System.currentTimeMillis()).setContentIntent(pendingIntent).setContentText(zad);
+        }
+        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 string = context.getResources().getString(com.google.android.gms.base.R.string.common_google_play_services_notification_channel_name);
+                if (notificationChannel == null) {
+                    notificationManager.createNotificationChannel(new NotificationChannel("com.google.android.gms.availability", string, 4));
+                } else if (!string.contentEquals(notificationChannel.getName())) {
+                    notificationChannel.setName(string);
+                    notificationManager.createNotificationChannel(notificationChannel);
+                }
+            }
+            style.setChannelId(str2);
+        }
+        Notification build = style.build();
+        if (i == 1 || i == 2 || i == 3) {
+            GooglePlayServicesUtilLight.sCanceledAvailabilityNotification.set(false);
+            i2 = 10436;
+        } else {
+            i2 = 39789;
+        }
+        notificationManager.notify(i2, build);
+    }
+
+    public final void zaf(Context context) {
+        new zad(this, context).sendEmptyMessageDelayed(1, UnityAdsConstants.Timeout.INIT_TIMEOUT_MS);
+    }
+
+    @ResultIgnorabilityUnspecified
+    public final boolean zag(@NonNull Activity activity, @NonNull LifecycleFragment lifecycleFragment, int i, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        Dialog zaa2 = zaa(activity, i, zag.zad(lifecycleFragment, getErrorResolutionIntent(activity, i, "d"), 2), onCancelListener, null);
+        if (zaa2 == null) {
+            return false;
+        }
+        zad(activity, zaa2, GooglePlayServicesUtil.GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+
+    public final boolean zah(@NonNull Context context, @NonNull 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;
+    }
+
+    @Nullable
+    public Dialog getErrorDialog(@NonNull Activity activity, int i, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        return zaa(activity, i, zag.zab(activity, getErrorResolutionIntent(activity, i, "d"), i2), onCancelListener, null);
+    }
+
+    @Nullable
+    public PendingIntent getErrorResolutionPendingIntent(@NonNull Context context, @NonNull ConnectionResult connectionResult) {
+        return connectionResult.hasResolution() ? connectionResult.getResolution() : getErrorResolutionPendingIntent(context, connectionResult.getErrorCode(), 0);
+    }
+
+    @Override // com.google.android.gms.common.GoogleApiAvailabilityLight
+    @ShowFirstParty
+    @KeepForSdk
+    public int isGooglePlayServicesAvailable(@NonNull Context context, int i) {
+        return super.isGooglePlayServicesAvailable(context, i);
+    }
+
+    @ResultIgnorabilityUnspecified
+    public boolean showErrorDialogFragment(@NonNull Activity activity, int i, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        Dialog errorDialog = getErrorDialog(activity, i, i2, onCancelListener);
+        if (errorDialog == null) {
+            return false;
+        }
+        zad(activity, errorDialog, GooglePlayServicesUtil.GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+
+    @NonNull
+    public Task<Void> checkApiAvailability(@NonNull HasApiKey<?> hasApiKey, @NonNull 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(@NonNull Context context, @NonNull ConnectionResult connectionResult) {
+        zae(context, connectionResult.getErrorCode(), null, getErrorResolutionPendingIntent(context, connectionResult));
+    }
+
+    @Nullable
+    public Dialog getErrorDialog(@NonNull Fragment fragment, int i, int i2) {
+        return getErrorDialog(fragment, i, i2, (DialogInterface.OnCancelListener) null);
+    }
+
+    public boolean showErrorDialogFragment(@NonNull Activity activity, int i, @NonNull ActivityResultLauncher<IntentSenderRequest> activityResultLauncher, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        Dialog zaa2 = zaa(activity, i, null, onCancelListener, new zac(this, activity, i, activityResultLauncher));
+        if (zaa2 == null) {
+            return false;
+        }
+        zad(activity, zaa2, GooglePlayServicesUtil.GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+
+    @Nullable
+    public Dialog getErrorDialog(@NonNull Fragment fragment, int i, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        return zaa(fragment.requireContext(), i, zag.zac(fragment, getErrorResolutionIntent(fragment.requireContext(), i, "d"), i2), onCancelListener, null);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GoogleApiAvailabilityLight.java

@@ -0,0 +1,190 @@
+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.net.Uri;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class GoogleApiAvailabilityLight {
+
+    @NonNull
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
+
+    @NonNull
+    @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() {
+    }
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static GoogleApiAvailabilityLight getInstance() {
+        return zza;
+    }
+
+    @KeepForSdk
+    public void cancelAvailabilityErrorNotifications(@NonNull Context context) {
+        GooglePlayServicesUtilLight.cancelAvailabilityErrorNotifications(context);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public int getApkVersion(@NonNull Context context) {
+        return GooglePlayServicesUtilLight.getApkVersion(context);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public int getClientVersion(@NonNull Context context) {
+        return GooglePlayServicesUtilLight.getClientVersion(context);
+    }
+
+    @Deprecated
+    @Nullable
+    @ShowFirstParty
+    @KeepForSdk
+    public Intent getErrorResolutionIntent(int i) {
+        return getErrorResolutionIntent(null, i, null);
+    }
+
+    @Nullable
+    @KeepForSdk
+    public PendingIntent getErrorResolutionPendingIntent(@NonNull Context context, int i, int i2) {
+        return getErrorResolutionPendingIntent(context, i, i2, null);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public String getErrorString(int i) {
+        return GooglePlayServicesUtilLight.getErrorString(i);
+    }
+
+    @ResultIgnorabilityUnspecified
+    @HideFirstParty
+    @KeepForSdk
+    public int isGooglePlayServicesAvailable(@NonNull Context context) {
+        return isGooglePlayServicesAvailable(context, GOOGLE_PLAY_SERVICES_VERSION_CODE);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public boolean isPlayServicesPossiblyUpdating(@NonNull Context context, int i) {
+        return GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(context, i);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public boolean isPlayStorePossiblyUpdating(@NonNull Context context, int i) {
+        return GooglePlayServicesUtilLight.isPlayStorePossiblyUpdating(context, i);
+    }
+
+    @KeepForSdk
+    public boolean isUninstalledAppPossiblyUpdating(@NonNull Context context, @NonNull String str) {
+        return GooglePlayServicesUtilLight.zza(context, str);
+    }
+
+    @KeepForSdk
+    public boolean isUserResolvableError(int i) {
+        return GooglePlayServicesUtilLight.isUserRecoverableError(i);
+    }
+
+    @KeepForSdk
+    public void verifyGooglePlayServicesIsAvailable(@NonNull Context context, int i) throws GooglePlayServicesRepairableException, GooglePlayServicesNotAvailableException {
+        GooglePlayServicesUtilLight.ensurePlayServicesAvailable(context, i);
+    }
+
+    @Nullable
+    @ShowFirstParty
+    @KeepForSdk
+    public Intent getErrorResolutionIntent(@Nullable Context context, int i, @Nullable String str) {
+        if (i != 1 && i != 2) {
+            if (i != 3) {
+                return null;
+            }
+            Uri fromParts = Uri.fromParts("package", "com.google.android.gms", null);
+            Intent intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS");
+            intent.setData(fromParts);
+            return intent;
+        }
+        if (context != null && DeviceProperties.isWearableWithoutPlayStore(context)) {
+            Intent intent2 = new Intent("com.google.android.clockwork.home.UPDATE_ANDROID_WEAR_ACTION");
+            intent2.setPackage("com.google.android.wearable.app");
+            return intent2;
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append("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) {
+            }
+        }
+        String sb2 = sb.toString();
+        Intent intent3 = new Intent("android.intent.action.VIEW");
+        Uri.Builder appendQueryParameter = Uri.parse("market://details").buildUpon().appendQueryParameter("id", "com.google.android.gms");
+        if (!TextUtils.isEmpty(sb2)) {
+            appendQueryParameter.appendQueryParameter("pcampaignid", sb2);
+        }
+        intent3.setData(appendQueryParameter.build());
+        intent3.setPackage("com.android.vending");
+        intent3.addFlags(524288);
+        return intent3;
+    }
+
+    @Nullable
+    @ShowFirstParty
+    @KeepForSdk
+    public PendingIntent getErrorResolutionPendingIntent(@NonNull Context context, int i, int i2, @Nullable String str) {
+        Intent errorResolutionIntent = getErrorResolutionIntent(context, i, str);
+        if (errorResolutionIntent == null) {
+            return null;
+        }
+        return PendingIntent.getActivity(context, i2, errorResolutionIntent, com.google.android.gms.internal.common.zzd.zza | 134217728);
+    }
+
+    @KeepForSdk
+    public int isGooglePlayServicesAvailable(@NonNull Context context, int i) {
+        int isGooglePlayServicesAvailable = GooglePlayServicesUtilLight.isGooglePlayServicesAvailable(context, i);
+        if (GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(context, isGooglePlayServicesAvailable)) {
+            return 18;
+        }
+        return isGooglePlayServicesAvailable;
+    }
+}

decompiled-community/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: classes2.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\" />");
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GooglePlayServicesManifestException.java

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

decompiled-community/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: classes2.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\" />");
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GooglePlayServicesNotAvailableException.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common;
+
+/* loaded from: classes2.dex */
+public final class GooglePlayServicesNotAvailableException extends Exception {
+    public static final /* synthetic */ int $r8$clinit = 0;
+    public final int errorCode;
+
+    public GooglePlayServicesNotAvailableException(int i) {
+        this.errorCode = i;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GooglePlayServicesRepairableException.java

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

decompiled-community/sources/com/google/android/gms/common/GooglePlayServicesUtil.java

@@ -0,0 +1,130 @@
+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.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.Fragment;
+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.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+/* loaded from: classes2.dex */
+public final class GooglePlayServicesUtil extends GooglePlayServicesUtilLight {
+
+    @NonNull
+    public static final String GMS_ERROR_DIALOG = "GooglePlayServicesErrorDialog";
+
+    @NonNull
+    @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;
+
+    @NonNull
+    public static final String GOOGLE_PLAY_STORE_PACKAGE = "com.android.vending";
+
+    private GooglePlayServicesUtil() {
+    }
+
+    @Nullable
+    @Deprecated
+    public static Dialog getErrorDialog(int i, @NonNull Activity activity, int i2) {
+        return getErrorDialog(i, activity, i2, null);
+    }
+
+    @NonNull
+    @Deprecated
+    public static PendingIntent getErrorPendingIntent(int i, @NonNull Context context, int i2) {
+        return GoogleApiAvailabilityLight.getInstance().getErrorResolutionPendingIntent(context, i, i2);
+    }
+
+    @NonNull
+    @Deprecated
+    public static String getErrorString(int i) {
+        return GooglePlayServicesUtilLight.getErrorString(i);
+    }
+
+    @NonNull
+    public static Context getRemoteContext(@NonNull Context context) {
+        return GooglePlayServicesUtilLight.getRemoteContext(context);
+    }
+
+    @NonNull
+    public static Resources getRemoteResource(@NonNull Context context) {
+        return GooglePlayServicesUtilLight.getRemoteResource(context);
+    }
+
+    @ResultIgnorabilityUnspecified
+    @HideFirstParty
+    @Deprecated
+    public static int isGooglePlayServicesAvailable(@NonNull Context context) {
+        return GooglePlayServicesUtilLight.isGooglePlayServicesAvailable(context);
+    }
+
+    @Deprecated
+    public static boolean isUserRecoverableError(int i) {
+        return GooglePlayServicesUtilLight.isUserRecoverableError(i);
+    }
+
+    @ResultIgnorabilityUnspecified
+    @Deprecated
+    public static boolean showErrorDialogFragment(int i, @NonNull Activity activity, int i2) {
+        return showErrorDialogFragment(i, activity, i2, null);
+    }
+
+    @Deprecated
+    public static void showErrorNotification(int i, @NonNull Context context) {
+        GoogleApiAvailability googleApiAvailability = GoogleApiAvailability.getInstance();
+        if (GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(context, i) || GooglePlayServicesUtilLight.isPlayStorePossiblyUpdating(context, i)) {
+            googleApiAvailability.zaf(context);
+        } else {
+            googleApiAvailability.showErrorNotification(context, i);
+        }
+    }
+
+    @Nullable
+    @Deprecated
+    public static Dialog getErrorDialog(int i, @NonNull Activity activity, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        if (true == GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(activity, i)) {
+            i = 18;
+        }
+        return GoogleApiAvailability.getInstance().getErrorDialog(activity, i, i2, onCancelListener);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static int isGooglePlayServicesAvailable(@NonNull Context context, int i) {
+        return GooglePlayServicesUtilLight.isGooglePlayServicesAvailable(context, i);
+    }
+
+    @ResultIgnorabilityUnspecified
+    @Deprecated
+    public static boolean showErrorDialogFragment(int i, @NonNull Activity activity, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        return showErrorDialogFragment(i, activity, null, i2, onCancelListener);
+    }
+
+    @ResultIgnorabilityUnspecified
+    public static boolean showErrorDialogFragment(int i, @NonNull Activity activity, @Nullable Fragment fragment, int i2, @Nullable DialogInterface.OnCancelListener onCancelListener) {
+        if (true == GooglePlayServicesUtilLight.isPlayServicesPossiblyUpdating(activity, i)) {
+            i = 18;
+        }
+        int i3 = i;
+        GoogleApiAvailability googleApiAvailability = GoogleApiAvailability.getInstance();
+        if (fragment == null) {
+            return googleApiAvailability.showErrorDialogFragment(activity, i3, i2, onCancelListener);
+        }
+        Dialog zaa = googleApiAvailability.zaa(activity, i3, zag.zac(fragment, GoogleApiAvailability.getInstance().getErrorResolutionIntent(activity, i3, "d"), i2), onCancelListener, null);
+        if (zaa == null) {
+            return false;
+        }
+        googleApiAvailability.zad(activity, zaa, GMS_ERROR_DIALOG, onCancelListener);
+        return true;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GooglePlayServicesUtilLight.java

@@ -0,0 +1,356 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.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.zzah;
+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.wrappers.Wrappers;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class GooglePlayServicesUtilLight {
+
+    @KeepForSdk
+    static final int GMS_AVAILABILITY_NOTIFICATION_ID = 10436;
+
+    @KeepForSdk
+    static final int GMS_GENERAL_ERROR_NOTIFICATION_ID = 39789;
+
+    @NonNull
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_GAMES_PACKAGE = "com.google.android.play.games";
+
+    @NonNull
+    @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;
+
+    @NonNull
+    @KeepForSdk
+    public static final String GOOGLE_PLAY_STORE_PACKAGE = "com.android.vending";
+
+    @VisibleForTesting
+    static boolean zza;
+    private static boolean zzb;
+
+    @KeepForSdk
+    @Deprecated
+    static final AtomicBoolean sCanceledAvailabilityNotification = new AtomicBoolean();
+    private static final AtomicBoolean zzc = new AtomicBoolean();
+
+    @KeepForSdk
+    public GooglePlayServicesUtilLight() {
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static void cancelAvailabilityErrorNotifications(@NonNull Context context) {
+        if (sCanceledAvailabilityNotification.getAndSet(true)) {
+            return;
+        }
+        try {
+            NotificationManager notificationManager = (NotificationManager) context.getSystemService("notification");
+            if (notificationManager != null) {
+                notificationManager.cancel(GMS_AVAILABILITY_NOTIFICATION_ID);
+            }
+        } catch (SecurityException unused) {
+        }
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static void enableUsingApkIndependentContext() {
+        zzc.set(true);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static void ensurePlayServicesAvailable(@NonNull 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(@NonNull 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(@NonNull Context context) {
+        Preconditions.checkState(true);
+        return ClientLibraryUtils.getClientVersion(context, context.getPackageName());
+    }
+
+    @Nullable
+    @KeepForSdk
+    @Deprecated
+    public static PendingIntent getErrorPendingIntent(int i, @NonNull Context context, int i2) {
+        return GoogleApiAvailabilityLight.getInstance().getErrorResolutionPendingIntent(context, i, i2);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static String getErrorString(int i) {
+        return ConnectionResult.zza(i);
+    }
+
+    @Deprecated
+    @Nullable
+    @ShowFirstParty
+    @KeepForSdk
+    public static Intent getGooglePlayServicesAvailabilityRecoveryIntent(int i) {
+        return GoogleApiAvailabilityLight.getInstance().getErrorResolutionIntent(null, i, null);
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static Context getRemoteContext(@NonNull Context context) {
+        try {
+            return context.createPackageContext("com.google.android.gms", 3);
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static Resources getRemoteResource(@NonNull Context context) {
+        try {
+            return context.getPackageManager().getResourcesForApplication("com.google.android.gms");
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    public static boolean honorsDebugCertificates(@NonNull 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 e) {
+                    Log.w("GooglePlayServicesUtil", "Cannot find Google Play services package name.", e);
+                    zza = true;
+                }
+            }
+            return zzb || !DeviceProperties.isUserBuild();
+        } catch (Throwable th) {
+            zza = true;
+            throw th;
+        }
+    }
+
+    @ResultIgnorabilityUnspecified
+    @Deprecated
+    @HideFirstParty
+    @KeepForSdk
+    public static int isGooglePlayServicesAvailable(@NonNull Context context) {
+        return isGooglePlayServicesAvailable(context, GOOGLE_PLAY_SERVICES_VERSION_CODE);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static boolean isGooglePlayServicesUid(@NonNull Context context, int i) {
+        return UidVerifier.isGooglePlayServicesUid(context, i);
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static boolean isPlayServicesPossiblyUpdating(@NonNull 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(@NonNull Context context, int i) {
+        if (i == 9) {
+            return zza(context, "com.android.vending");
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    @TargetApi(18)
+    public static boolean isRestrictedUserProfile(@NonNull 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"));
+    }
+
+    @ShowFirstParty
+    @KeepForSdk
+    @Deprecated
+    public static boolean isSidewinderDevice(@NonNull 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(@NonNull Context context, int i, @NonNull 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(@NonNull 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 = zzah.zza(context);
+            if (zza2 == 0) {
+                throw new GooglePlayServicesMissingManifestValueException();
+            }
+            if (zza2 != GOOGLE_PLAY_SERVICES_VERSION_CODE) {
+                throw new GooglePlayServicesIncorrectManifestValueException(zza2);
+            }
+        }
+        boolean z = (DeviceProperties.isWearableWithoutPlayStore(context) || DeviceProperties.zzb(context)) ? false : true;
+        Preconditions.checkArgument(i >= 0);
+        String packageName = context.getPackageName();
+        PackageManager packageManager = context.getPackageManager();
+        if (z) {
+            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)) {
+                if (z) {
+                    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 (!z || packageInfo == null || packageInfo.signatures[0].equals(packageInfo2.signatures[0])) {
+                    if (com.google.android.gms.common.util.zza.zza(packageInfo2.versionCode) >= com.google.android.gms.common.util.zza.zza(i)) {
+                        ApplicationInfo applicationInfo = packageInfo2.applicationInfo;
+                        if (applicationInfo == null) {
+                            try {
+                                applicationInfo = packageManager.getApplicationInfo("com.google.android.gms", 0);
+                            } catch (PackageManager.NameNotFoundException e) {
+                                Log.wtf("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play services, but they're missing when getting application info."), e);
+                                return 1;
+                            }
+                        }
+                        return !applicationInfo.enabled ? 3 : 0;
+                    }
+                    Log.w("GooglePlayServicesUtil", "Google Play services out of date for " + packageName + ".  Requires " + i + " but found " + packageInfo2.versionCode);
+                    return 2;
+                }
+                Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play Store, but its signature doesn't match that of Google Play services."));
+            } else {
+                Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play services, but their signature is invalid."));
+            }
+            return 9;
+        } catch (PackageManager.NameNotFoundException unused3) {
+            Log.w("GooglePlayServicesUtil", String.valueOf(packageName).concat(" requires Google Play services, but they are missing."));
+            return 1;
+        }
+    }
+}

decompiled-community/sources/com/google/android/gms/common/GoogleSignatureVerifier.java

@@ -0,0 +1,215 @@
+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 androidx.annotation.NonNull;
+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: classes2.dex */
+public class GoogleSignatureVerifier {
+    private static GoogleSignatureVerifier zza;
+    private static volatile Set zzb;
+    private final Context zzc;
+    private volatile String zzd;
+
+    public GoogleSignatureVerifier(@NonNull Context context) {
+        this.zzc = context.getApplicationContext();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static GoogleSignatureVerifier getInstance(@NonNull 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) {
+            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;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0032  */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0047 A[RETURN] */
+    /* JADX WARN: Removed duplicated region for block: B:23:0x0039  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static final boolean zzb(@androidx.annotation.NonNull android.content.pm.PackageInfo r4, boolean r5) {
+        /*
+            r0 = 1
+            r1 = 0
+            if (r5 == 0) goto L27
+            if (r4 == 0) goto L29
+            java.lang.String r2 = "com.android.vending"
+            java.lang.String r3 = r4.packageName
+            boolean r2 = r2.equals(r3)
+            if (r2 != 0) goto L1a
+            java.lang.String r2 = r4.packageName
+            java.lang.String r3 = "com.google.android.gms"
+            boolean r2 = r3.equals(r2)
+            if (r2 == 0) goto L27
+        L1a:
+            android.content.pm.ApplicationInfo r5 = r4.applicationInfo
+            if (r5 != 0) goto L20
+        L1e:
+            r5 = r1
+            goto L27
+        L20:
+            int r5 = r5.flags
+            r5 = r5 & 129(0x81, float:1.81E-43)
+            if (r5 == 0) goto L1e
+            r5 = r0
+        L27:
+            r2 = r4
+            goto L2a
+        L29:
+            r2 = 0
+        L2a:
+            if (r4 == 0) goto L48
+            android.content.pm.Signature[] r4 = r2.signatures
+            if (r4 == 0) goto L48
+            if (r5 == 0) goto L39
+            com.google.android.gms.common.zzj[] r4 = com.google.android.gms.common.zzm.zza
+            com.google.android.gms.common.zzj r4 = zza(r2, r4)
+            goto L45
+        L39:
+            com.google.android.gms.common.zzj[] r4 = new com.google.android.gms.common.zzj[r0]
+            com.google.android.gms.common.zzj[] r5 = com.google.android.gms.common.zzm.zza
+            r5 = r5[r1]
+            r4[r1] = r5
+            com.google.android.gms.common.zzj r4 = zza(r2, r4)
+        L45:
+            if (r4 == 0) goto L48
+            return r0
+        L48:
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.GoogleSignatureVerifier.zzb(android.content.pm.PackageInfo, boolean):boolean");
+    }
+
+    @SuppressLint({"PackageManagerGetSignatures"})
+    private final zzx zzc(String str, boolean z, boolean z2) {
+        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 e) {
+                return zzx.zzd("no pkg ".concat(str), e);
+            }
+        }
+        if (zzc.zza) {
+            this.zzd = str;
+        }
+        return zzc;
+    }
+
+    @KeepForSdk
+    public boolean isGooglePublicSignedPackage(@NonNull 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 i2 = 0;
+            while (true) {
+                if (i2 >= length) {
+                    Preconditions.checkNotNull(zzc);
+                    break;
+                }
+                zzc = zzc(packagesForUid[i2], false, false);
+                if (zzc.zza) {
+                    break;
+                }
+                i2++;
+            }
+        } else {
+            zzc = zzx.zzc("no pkgs");
+        }
+        zzc.zze();
+        return zzc.zza;
+    }
+}

decompiled-community/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: classes2.dex */
+public class GoogleSourceStampsChecker {
+}

decompiled-community/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: classes2.dex */
+public final class GoogleSourceStampsResult {
+}

decompiled-community/sources/com/google/android/gms/common/PackageSignatureVerifier.java

@@ -0,0 +1,89 @@
+package com.google.android.gms.common;
+
+import android.content.Context;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.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: classes2.dex */
+public class PackageSignatureVerifier {
+
+    @Nullable
+    @VisibleForTesting
+    static volatile zzac zza;
+
+    @Nullable
+    private static zzad zzb;
+
+    private static zzad zza(Context context) {
+        zzad zzadVar;
+        synchronized (PackageSignatureVerifier.class) {
+            try {
+                if (zzb == null) {
+                    zzb = new zzad(context);
+                }
+                zzadVar = zzb;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zzadVar;
+    }
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public PackageVerificationResult queryPackageSignatureVerified(@NonNull Context context, @NonNull String str) {
+        PackageVerificationResult packageVerificationResult;
+        String str2;
+        PackageVerificationResult packageVerificationResult2;
+        boolean honorsDebugCertificates = GooglePlayServicesUtilLight.honorsDebugCertificates(context);
+        zza(context);
+        if (!zzn.zzf()) {
+            throw new zzae();
+        }
+        String concat = String.valueOf(str).concat(true != honorsDebugCertificates ? "-0" : "-1");
+        if (zza != null) {
+            str2 = zza.zza;
+            if (str2.equals(concat)) {
+                packageVerificationResult2 = zza.zzb;
+                return packageVerificationResult2;
+            }
+        }
+        zza(context);
+        zzx zzc = zzn.zzc(str, honorsDebugCertificates, false, false);
+        if (!zzc.zza) {
+            Preconditions.checkNotNull(zzc.zzb);
+            return PackageVerificationResult.zza(str, zzc.zzb, zzc.zzc);
+        }
+        zza = new zzac(concat, PackageVerificationResult.zzd(str, zzc.zzd));
+        packageVerificationResult = zza.zzb;
+        return packageVerificationResult;
+    }
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public PackageVerificationResult queryPackageSignatureVerifiedWithRetry(@NonNull Context context, @NonNull String str) {
+        try {
+            PackageVerificationResult queryPackageSignatureVerified = queryPackageSignatureVerified(context, str);
+            queryPackageSignatureVerified.zzb();
+            return queryPackageSignatureVerified;
+        } catch (SecurityException e) {
+            PackageVerificationResult queryPackageSignatureVerified2 = queryPackageSignatureVerified(context, str);
+            if (!queryPackageSignatureVerified2.zzc()) {
+                return queryPackageSignatureVerified2;
+            }
+            Log.e("PkgSignatureVerifier", "Got flaky result during package signature verification", e);
+            return queryPackageSignatureVerified2;
+        }
+    }
+}

decompiled-community/sources/com/google/android/gms/common/PackageVerificationResult.java

@@ -0,0 +1,45 @@
+package com.google.android.gms.common;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes2.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 z, String str2, Throwable th) {
+        this.zza = str;
+        this.zzb = z;
+        this.zzc = str2;
+        this.zzd = th;
+    }
+
+    @NonNull
+    public static PackageVerificationResult zza(@NonNull String str, @NonNull String str2, Throwable th) {
+        return new PackageVerificationResult(str, 1, false, str2, th);
+    }
+
+    @NonNull
+    public static PackageVerificationResult zzd(@NonNull String str, int i) {
+        return new PackageVerificationResult(str, i, true, null, null);
+    }
+
+    public final void zzb() {
+        if (this.zzb) {
+            return;
+        }
+        String str = this.zzc;
+        Throwable th = this.zzd;
+        String concat = "PackageVerificationRslt: ".concat(String.valueOf(str));
+        if (th == null) {
+            throw new SecurityException(concat);
+        }
+        throw new SecurityException(concat, th);
+    }
+
+    public final boolean zzc() {
+        return this.zzb;
+    }
+}

decompiled-community/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: classes2.dex */
+final class ProGuardCanary {
+
+    @KeepForSdk
+    static final String CANARY = "gms_proguard_canary";
+
+    private ProGuardCanary() {
+    }
+}

decompiled-community/sources/com/google/android/gms/common/R.java

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

decompiled-community/sources/com/google/android/gms/common/Scopes.java

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

decompiled-community/sources/com/google/android/gms/common/SignInButton.java

@@ -0,0 +1,131 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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: classes2.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;
+
+    @Nullable
+    private View.OnClickListener zad;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ButtonSize {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ColorScheme {
+    }
+
+    public SignInButton(@NonNull 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 i2 = this.zab;
+            zaaa zaaaVar = new zaaa(context, null);
+            zaaaVar.zaa(context.getResources(), i, i2);
+            this.zac = zaaaVar;
+        }
+        addView(this.zac);
+        this.zac.setEnabled(isEnabled());
+        this.zac.setOnClickListener(this);
+    }
+
+    @Override // android.view.View.OnClickListener
+    public void onClick(@NonNull 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 z) {
+        super.setEnabled(z);
+        this.zac.setEnabled(z);
+    }
+
+    @Override // android.view.View
+    public void setOnClickListener(@Nullable View.OnClickListener onClickListener) {
+        this.zad = onClickListener;
+        View view = this.zac;
+        if (view != null) {
+            view.setOnClickListener(this);
+        }
+    }
+
+    @Deprecated
+    public void setScopes(@NonNull Scope[] scopeArr) {
+        setStyle(this.zaa, this.zab);
+    }
+
+    public void setSize(int i) {
+        setStyle(i, this.zab);
+    }
+
+    public void setStyle(int i, int i2) {
+        this.zaa = i;
+        this.zab = i2;
+        zaa(getContext());
+    }
+
+    public SignInButton(@NonNull Context context, @Nullable AttributeSet attributeSet) {
+        this(context, attributeSet, 0);
+    }
+
+    @Deprecated
+    public void setStyle(int i, int i2, @NonNull Scope[] scopeArr) {
+        setStyle(i, i2);
+    }
+
+    public SignInButton(@NonNull Context context, @Nullable 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;
+        }
+    }
+}

decompiled-community/sources/com/google/android/gms/common/SupportErrorDialogFragment.java

@@ -0,0 +1,66 @@
+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.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.fragment.app.DialogFragment;
+import androidx.fragment.app.FragmentManager;
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes2.dex */
+public class SupportErrorDialogFragment extends DialogFragment {
+    private Dialog zaa;
+    private DialogInterface.OnCancelListener zab;
+
+    @Nullable
+    private Dialog zac;
+
+    @NonNull
+    public static SupportErrorDialogFragment newInstance(@NonNull Dialog dialog) {
+        return newInstance(dialog, null);
+    }
+
+    @Override // androidx.fragment.app.DialogFragment, android.content.DialogInterface.OnCancelListener
+    public void onCancel(@NonNull DialogInterface dialogInterface) {
+        DialogInterface.OnCancelListener onCancelListener = this.zab;
+        if (onCancelListener != null) {
+            onCancelListener.onCancel(dialogInterface);
+        }
+    }
+
+    @Override // androidx.fragment.app.DialogFragment
+    @NonNull
+    public Dialog onCreateDialog(@Nullable 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.DialogFragment
+    public void show(@NonNull FragmentManager fragmentManager, @Nullable String str) {
+        super.show(fragmentManager, str);
+    }
+
+    @NonNull
+    public static SupportErrorDialogFragment newInstance(@NonNull Dialog dialog, @Nullable 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;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/UserRecoverableException.java

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

decompiled-community/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: classes2.dex */
+public @interface KeepForSdk {
+}

decompiled-community/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: classes2.dex */
+public @interface KeepForSdkWithFieldsAndMethods {
+}

decompiled-community/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: classes2.dex */
+public @interface KeepForSdkWithMembers {
+}

decompiled-community/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: classes2.dex */
+public @interface KeepName {
+}

decompiled-community/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: classes2.dex */
+public @interface NonNullApi {
+}

decompiled-community/sources/com/google/android/gms/common/api/Api.java

@@ -0,0 +1,218 @@
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+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 java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public final class Api<O extends ApiOptions> {
+    private final AbstractClientBuilder zaa;
+    private final ClientKey zab;
+    private final String zac;
+
+    @KeepForSdk
+    public static abstract class AbstractClientBuilder<T extends Client, O> extends BaseClientBuilder<T, O> {
+        @NonNull
+        @KeepForSdk
+        @Deprecated
+        public T buildClient(@NonNull Context context, @NonNull Looper looper, @NonNull ClientSettings clientSettings, @NonNull O o, @NonNull GoogleApiClient.ConnectionCallbacks connectionCallbacks, @NonNull GoogleApiClient.OnConnectionFailedListener onConnectionFailedListener) {
+            return buildClient(context, looper, clientSettings, (ClientSettings) o, (ConnectionCallbacks) connectionCallbacks, (OnConnectionFailedListener) onConnectionFailedListener);
+        }
+
+        @NonNull
+        @KeepForSdk
+        public T buildClient(@NonNull Context context, @NonNull Looper looper, @NonNull ClientSettings clientSettings, @NonNull O o, @NonNull ConnectionCallbacks connectionCallbacks, @NonNull OnConnectionFailedListener onConnectionFailedListener) {
+            throw new UnsupportedOperationException("buildClient must be implemented");
+        }
+    }
+
+    @KeepForSdk
+    public interface AnyClient {
+    }
+
+    @KeepForSdk
+    public static class AnyClientKey<C extends AnyClient> {
+    }
+
+    public interface ApiOptions {
+
+        @NonNull
+        public static final NoOptions NO_OPTIONS = new NoOptions(null);
+
+        public interface HasAccountOptions extends HasOptions, NotRequiredOptions {
+            @NonNull
+            Account getAccount();
+        }
+
+        public interface HasGoogleSignInAccountOptions extends HasOptions {
+            @Nullable
+            GoogleSignInAccount getGoogleSignInAccount();
+        }
+
+        public interface HasOptions extends ApiOptions {
+        }
+
+        public static final class NoOptions implements NotRequiredOptions {
+            private NoOptions() {
+            }
+
+            public /* synthetic */ NoOptions(zaa zaaVar) {
+            }
+        }
+
+        public interface NotRequiredOptions extends ApiOptions {
+        }
+
+        public interface Optional extends HasOptions, NotRequiredOptions {
+        }
+    }
+
+    @VisibleForTesting
+    @KeepForSdk
+    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;
+
+        @NonNull
+        @KeepForSdk
+        public List<Scope> getImpliedScopes(@Nullable O o) {
+            return Collections.emptyList();
+        }
+
+        @KeepForSdk
+        public int getPriority() {
+            return Integer.MAX_VALUE;
+        }
+    }
+
+    @KeepForSdk
+    public interface Client extends AnyClient {
+        @KeepForSdk
+        void connect(@NonNull BaseGmsClient.ConnectionProgressReportCallbacks connectionProgressReportCallbacks);
+
+        @KeepForSdk
+        void disconnect();
+
+        @KeepForSdk
+        void disconnect(@NonNull String str);
+
+        @KeepForSdk
+        void dump(@NonNull String str, @Nullable FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @Nullable String[] strArr);
+
+        @NonNull
+        @KeepForSdk
+        Feature[] getAvailableFeatures();
+
+        @NonNull
+        @KeepForSdk
+        String getEndpointPackageName();
+
+        @Nullable
+        @KeepForSdk
+        String getLastDisconnectMessage();
+
+        @KeepForSdk
+        int getMinApkVersion();
+
+        @KeepForSdk
+        void getRemoteService(@Nullable IAccountAccessor iAccountAccessor, @Nullable Set<Scope> set);
+
+        @NonNull
+        @KeepForSdk
+        Feature[] getRequiredFeatures();
+
+        @NonNull
+        @KeepForSdk
+        Set<Scope> getScopesForConnectionlessNonSignIn();
+
+        @Nullable
+        @KeepForSdk
+        IBinder getServiceBrokerBinder();
+
+        @NonNull
+        @KeepForSdk
+        Intent getSignInIntent();
+
+        @KeepForSdk
+        boolean isConnected();
+
+        @KeepForSdk
+        boolean isConnecting();
+
+        @KeepForSdk
+        void onUserSignOut(@NonNull BaseGmsClient.SignOutCallbacks signOutCallbacks);
+
+        @KeepForSdk
+        boolean providesSignIn();
+
+        @KeepForSdk
+        boolean requiresAccount();
+
+        @KeepForSdk
+        boolean requiresGooglePlayServices();
+
+        @KeepForSdk
+        boolean requiresSignIn();
+    }
+
+    @KeepForSdk
+    public static final class ClientKey<C extends Client> extends AnyClientKey<C> {
+    }
+
+    @KeepForSdk
+    public <C extends Client> Api(@NonNull String str, @NonNull AbstractClientBuilder<C, O> abstractClientBuilder, @NonNull 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;
+    }
+
+    @NonNull
+    public final AbstractClientBuilder zaa() {
+        return this.zaa;
+    }
+
+    @NonNull
+    public final AnyClientKey zab() {
+        return this.zab;
+    }
+
+    @NonNull
+    public final BaseClientBuilder zac() {
+        return this.zaa;
+    }
+
+    @NonNull
+    public final String zad() {
+        return this.zac;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/ApiException.java

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

decompiled-community/sources/com/google/android/gms/common/api/AvailabilityException.java

@@ -0,0 +1,55 @@
+package com.google.android.gms.common.api;
+
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.collection.ArrayMap;
+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;
+
+/* loaded from: classes2.dex */
+public class AvailabilityException extends Exception {
+    private final ArrayMap zaa;
+
+    public AvailabilityException(@NonNull ArrayMap arrayMap) {
+        this.zaa = arrayMap;
+    }
+
+    @NonNull
+    public ConnectionResult getConnectionResult(@NonNull GoogleApi<? extends Api.ApiOptions> googleApi) {
+        ArrayMap arrayMap = this.zaa;
+        ApiKey<? extends Api.ApiOptions> apiKey = googleApi.getApiKey();
+        Preconditions.checkArgument(arrayMap.get(apiKey) != null, "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
+    @NonNull
+    public String getMessage() {
+        ArrayList arrayList = new ArrayList();
+        boolean z = true;
+        for (ApiKey apiKey : this.zaa.keySet()) {
+            ConnectionResult connectionResult = (ConnectionResult) Preconditions.checkNotNull((ConnectionResult) this.zaa.get(apiKey));
+            z &= !connectionResult.isSuccess();
+            arrayList.add(apiKey.zaa() + ": " + String.valueOf(connectionResult));
+        }
+        StringBuilder sb = new StringBuilder();
+        if (z) {
+            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();
+    }
+
+    @NonNull
+    public ConnectionResult getConnectionResult(@NonNull HasApiKey<? extends Api.ApiOptions> hasApiKey) {
+        ArrayMap arrayMap = this.zaa;
+        ApiKey<? extends Api.ApiOptions> apiKey = hasApiKey.getApiKey();
+        Preconditions.checkArgument(arrayMap.get(apiKey) != null, "The given API (" + apiKey.zaa() + ") was not part of the availability request.");
+        return (ConnectionResult) Preconditions.checkNotNull((ConnectionResult) this.zaa.get(apiKey));
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/Batch.java

@@ -0,0 +1,77 @@
+package com.google.android.gms.common.api;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.api.internal.BasePendingResult;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.ArrayList;
+import java.util.List;
+
+/* loaded from: classes2.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;
+
+    public static final class Builder {
+        private final List zaa = new ArrayList();
+        private final GoogleApiClient zab;
+
+        public Builder(@NonNull GoogleApiClient googleApiClient) {
+            this.zab = googleApiClient;
+        }
+
+        @NonNull
+        @ResultIgnorabilityUnspecified
+        public <R extends Result> BatchResultToken<R> add(@NonNull PendingResult<R> pendingResult) {
+            BatchResultToken<R> batchResultToken = new BatchResultToken<>(this.zaa.size());
+            this.zaa.add(pendingResult);
+            return batchResultToken;
+        }
+
+        @NonNull
+        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();
+        int i = 0;
+        while (true) {
+            PendingResult[] pendingResultArr = this.zah;
+            if (i >= pendingResultArr.length) {
+                return;
+            }
+            pendingResultArr[i].cancel();
+            i++;
+        }
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // com.google.android.gms.common.api.internal.BasePendingResult
+    @NonNull
+    public BatchResult createFailedResult(@NonNull Status status) {
+        return new BatchResult(status, this.zah);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/BatchResult.java

@@ -0,0 +1,30 @@
+package com.google.android.gms.common.api;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes2.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
+    @NonNull
+    public Status getStatus() {
+        return this.zaa;
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public <R extends Result> R take(@NonNull 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);
+    }
+}

decompiled-community/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: classes2.dex */
+public final class BatchResultToken<R extends Result> {
+    protected final int mId;
+
+    public BatchResultToken(int i) {
+        this.mId = i;
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/BooleanResult.java

@@ -0,0 +1,49 @@
+package com.google.android.gms.common.api;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+
+/* loaded from: classes2.dex */
+public class BooleanResult implements Result {
+    private final Status zaa;
+    private final boolean zab;
+
+    @ShowFirstParty
+    @KeepForSdk
+    public BooleanResult(@NonNull Status status, boolean z) {
+        this.zaa = (Status) Preconditions.checkNotNull(status, "Status must not be null");
+        this.zab = z;
+    }
+
+    public final boolean equals(@Nullable 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
+    @NonNull
+    public Status getStatus() {
+        return this.zaa;
+    }
+
+    public boolean getValue() {
+        return this.zab;
+    }
+
+    public final int hashCode() {
+        return ((this.zaa.hashCode() + IronSourceError.ERROR_NON_EXISTENT_INSTANCE) * 31) + (this.zab ? 1 : 0);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/CommonStatusCodes.java

@@ -0,0 +1,87 @@
+package com.google.android.gms.common.api;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+/* loaded from: classes2.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() {
+    }
+
+    @NonNull
+    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 "unknown status code: " + i;
+            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";
+        }
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/DataBufferResponse.java

@@ -0,0 +1,77 @@
+package com.google.android.gms.common.api;
+
+import android.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.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: classes2.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
+    @NonNull
+    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
+    @Nullable
+    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
+    @NonNull
+    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
+    @NonNull
+    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(@NonNull AbstractDataBuffer abstractDataBuffer) {
+        super(abstractDataBuffer);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/GoogleApi$$ExternalSyntheticApiModelOutline0.java

@@ -0,0 +1,5 @@
+package com.google.android.gms.common.api;
+
+/* loaded from: classes2.dex */
+public abstract /* synthetic */ class GoogleApi$$ExternalSyntheticApiModelOutline0 {
+}

decompiled-community/sources/com/google/android/gms/common/api/GoogleApi.java

@@ -0,0 +1,429 @@
+package com.google.android.gms.common.api;
+
+import android.accounts.Account;
+import android.app.Activity;
+import android.content.Context;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.WorkerThread;
+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.tasks.Task;
+import com.google.android.gms.tasks.TaskCompletionSource;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+import java.util.Collections;
+import java.util.Set;
+
+/* loaded from: classes2.dex */
+public abstract class GoogleApi<O extends Api.ApiOptions> implements HasApiKey<O> {
+
+    @NonNull
+    protected final GoogleApiManager zaa;
+    private final Context zab;
+
+    @Nullable
+    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;
+    private final GoogleApiClient zai;
+    private final StatusExceptionMapper zaj;
+
+    @KeepForSdk
+    public static class Settings {
+
+        @NonNull
+        @KeepForSdk
+        public static final Settings DEFAULT_SETTINGS = new Builder().build();
+
+        @NonNull
+        public final StatusExceptionMapper zaa;
+
+        @NonNull
+        public final Looper zab;
+
+        @KeepForSdk
+        public static class Builder {
+            private StatusExceptionMapper zaa;
+            private Looper zab;
+
+            @KeepForSdk
+            public Builder() {
+            }
+
+            /* JADX WARN: Multi-variable type inference failed */
+            @NonNull
+            @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);
+            }
+
+            @NonNull
+            @KeepForSdk
+            public Builder setLooper(@NonNull Looper looper) {
+                Preconditions.checkNotNull(looper, "Looper must not be null.");
+                this.zab = looper;
+                return this;
+            }
+
+            @NonNull
+            @KeepForSdk
+            public Builder setMapper(@NonNull 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
+    @MainThread
+    public GoogleApi(@NonNull Activity activity, @NonNull Api<O> api, @NonNull O o, @NonNull Settings settings) {
+        this(activity, activity, api, o, settings);
+    }
+
+    private final BaseImplementation.ApiMethodImpl zad(int i, @NonNull BaseImplementation.ApiMethodImpl apiMethodImpl) {
+        apiMethodImpl.zak();
+        this.zaa.zau(this, i, apiMethodImpl);
+        return apiMethodImpl;
+    }
+
+    private final Task zae(int i, @NonNull TaskApiCall taskApiCall) {
+        TaskCompletionSource taskCompletionSource = new TaskCompletionSource();
+        this.zaa.zav(this, i, taskApiCall, taskCompletionSource, this.zaj);
+        return taskCompletionSource.getTask();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public GoogleApiClient asGoogleApiClient() {
+        return this.zai;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public ClientSettings.Builder createClientSettingsBuilder() {
+        Account account;
+        Set<Scope> emptySet;
+        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();
+            emptySet = googleSignInAccount2 == null ? Collections.emptySet() : googleSignInAccount2.getRequestedScopes();
+        } else {
+            emptySet = Collections.emptySet();
+        }
+        builder.zaa(emptySet);
+        builder.zac(this.zab.getClass().getName());
+        builder.setRealClientPackageName(this.zab.getPackageName());
+        return builder;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public Task<Boolean> disconnectService() {
+        return this.zaa.zan(this);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T doBestEffortWrite(@NonNull T t) {
+        zad(2, t);
+        return t;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T doRead(@NonNull T t) {
+        zad(0, t);
+        return t;
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @Deprecated
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends RegisterListenerMethod<A, ?>, U extends UnregisterListenerMethod<A, ?>> Task<Void> doRegisterEventListener(@NonNull T t, @NonNull U u) {
+        Preconditions.checkNotNull(t);
+        Preconditions.checkNotNull(u);
+        Preconditions.checkNotNull(t.getListenerKey(), "Listener has already been released.");
+        Preconditions.checkNotNull(u.getListenerKey(), "Listener has already been released.");
+        Preconditions.checkArgument(Objects.equal(t.getListenerKey(), u.getListenerKey()), "Listener registration and unregistration methods must be constructed with the same ListenerHolder.");
+        return this.zaa.zao(this, t, u, new Runnable() { // from class: com.google.android.gms.common.api.zad
+            @Override // java.lang.Runnable
+            public final void run() {
+            }
+        });
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public Task<Boolean> doUnregisterEventListener(@NonNull ListenerHolder.ListenerKey<?> listenerKey) {
+        return doUnregisterEventListener(listenerKey, 0);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T doWrite(@NonNull T t) {
+        zad(1, t);
+        return t;
+    }
+
+    @Nullable
+    public String getApiFallbackAttributionTag(@NonNull Context context) {
+        return null;
+    }
+
+    @Override // com.google.android.gms.common.api.HasApiKey
+    @NonNull
+    public final ApiKey<O> getApiKey() {
+        return this.zaf;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public O getApiOptions() {
+        return (O) this.zae;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public Context getApplicationContext() {
+        return this.zab;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public String getContextAttributionTag() {
+        return this.zac;
+    }
+
+    @Nullable
+    @KeepForSdk
+    @Deprecated
+    public String getContextFeatureId() {
+        return this.zac;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public Looper getLooper() {
+        return this.zag;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public <L> ListenerHolder<L> registerListener(@NonNull L l, @NonNull String str) {
+        return ListenerHolders.createListenerHolder(l, this.zag, str);
+    }
+
+    public final int zaa() {
+        return this.zah;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    @WorkerThread
+    public final Api.Client zab(Looper looper, zabq zabqVar) {
+        ClientSettings build = createClientSettingsBuilder().build();
+        Api.Client buildClient = ((Api.AbstractClientBuilder) Preconditions.checkNotNull(this.zad.zaa())).buildClient(this.zab, looper, 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(@androidx.annotation.NonNull android.app.Activity r2, @androidx.annotation.NonNull com.google.android.gms.common.api.Api<O> r3, @androidx.annotation.NonNull O r4, @androidx.annotation.NonNull 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");
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public <TResult, A extends Api.AnyClient> Task<TResult> doBestEffortWrite(@NonNull TaskApiCall<A, TResult> taskApiCall) {
+        return zae(2, taskApiCall);
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public <TResult, A extends Api.AnyClient> Task<TResult> doRead(@NonNull TaskApiCall<A, TResult> taskApiCall) {
+        return zae(0, taskApiCall);
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public Task<Boolean> doUnregisterEventListener(@NonNull ListenerHolder.ListenerKey<?> listenerKey, int i) {
+        Preconditions.checkNotNull(listenerKey, "Listener key cannot be null.");
+        return this.zaa.zap(this, listenerKey, i);
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public <TResult, A extends Api.AnyClient> Task<TResult> doWrite(@NonNull TaskApiCall<A, TResult> taskApiCall) {
+        return zae(1, taskApiCall);
+    }
+
+    private GoogleApi(@NonNull Context context, @Nullable Activity activity, Api api, Api.ApiOptions apiOptions, Settings settings) {
+        String apiFallbackAttributionTag;
+        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.");
+        Context context2 = (Context) Preconditions.checkNotNull(context.getApplicationContext(), "The provided context did not have an application context.");
+        this.zab = context2;
+        if (Build.VERSION.SDK_INT < 30) {
+            apiFallbackAttributionTag = getApiFallbackAttributionTag(context);
+        } else {
+            apiFallbackAttributionTag = context.getAttributionTag();
+        }
+        this.zac = apiFallbackAttributionTag;
+        this.zad = api;
+        this.zae = apiOptions;
+        this.zag = settings.zab;
+        ApiKey sharedApiKey = ApiKey.getSharedApiKey(api, apiOptions, apiFallbackAttributionTag);
+        this.zaf = sharedApiKey;
+        this.zai = new zabv(this);
+        GoogleApiManager zak = GoogleApiManager.zak(context2);
+        this.zaa = zak;
+        this.zah = zak.zaa();
+        this.zaj = settings.zaa;
+        if (activity != null && !(activity instanceof GoogleApiActivity) && Looper.myLooper() == Looper.getMainLooper()) {
+            zaae.zad(activity, zak, sharedApiKey);
+        }
+        zak.zaz(this);
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public <A extends Api.AnyClient> Task<Void> doRegisterEventListener(@NonNull 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.zao(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(@androidx.annotation.NonNull android.content.Context r2, @androidx.annotation.NonNull com.google.android.gms.common.api.Api<O> r3, @androidx.annotation.NonNull O r4, @androidx.annotation.NonNull android.os.Looper r5, @androidx.annotation.NonNull 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(@NonNull Context context, @NonNull Api<O> api, @NonNull O o, @NonNull Settings settings) {
+        this(context, (Activity) null, api, o, 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(@androidx.annotation.NonNull android.content.Context r2, @androidx.annotation.NonNull com.google.android.gms.common.api.Api<O> r3, @androidx.annotation.NonNull O r4, @androidx.annotation.NonNull 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");
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/GoogleApiActivity.java

@@ -0,0 +1,125 @@
+package com.google.android.gms.common.api;
+
+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 androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+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 csdk.gluads.Consts;
+
+@KeepName
+/* loaded from: classes2.dex */
+public class GoogleApiActivity extends Activity implements DialogInterface.OnCancelListener {
+
+    @VisibleForTesting
+    protected int zaa = 0;
+
+    @NonNull
+    public static Intent zaa(@NonNull Context context, @NonNull PendingIntent pendingIntent, int i, boolean z) {
+        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", z);
+        return intent;
+    }
+
+    private final void zab() {
+        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 {
+            startIntentSenderForResult(pendingIntent.getIntentSender(), 1, null, 0, 0, 0);
+            this.zaa = 1;
+        } catch (ActivityNotFoundException e) {
+            if (extras.getBoolean("notify_manager", true)) {
+                GoogleApiManager.zak(this).zax(new ConnectionResult(22, null), getIntent().getIntExtra("failing_client_id", -1));
+            } else {
+                String str = "Activity not found while launching " + pendingIntent.toString() + Consts.STRING_PERIOD;
+                if (Build.FINGERPRINT.contains("generic")) {
+                    str = str.concat(" This may occur when resolving Google Play services connection issues on emulators with Google APIs but not Google Play Store.");
+                }
+                Log.e("GoogleApiActivity", str, e);
+            }
+            this.zaa = 1;
+            finish();
+        } catch (IntentSender.SendIntentException e2) {
+            Log.e("GoogleApiActivity", "Failed to launch pendingIntent", e2);
+            finish();
+        }
+    }
+
+    @Override // android.app.Activity
+    public final void onActivityResult(int i, int i2, @NonNull Intent intent) {
+        super.onActivityResult(i, i2, intent);
+        if (i == 1) {
+            boolean booleanExtra = getIntent().getBooleanExtra("notify_manager", true);
+            this.zaa = 0;
+            setResult(i2, intent);
+            if (booleanExtra) {
+                GoogleApiManager zak = GoogleApiManager.zak(this);
+                if (i2 == -1) {
+                    zak.zay();
+                } else if (i2 == 0) {
+                    zak.zax(new ConnectionResult(13, null), getIntent().getIntExtra("failing_client_id", -1));
+                }
+            }
+        } else if (i == 2) {
+            this.zaa = 0;
+            setResult(i2, intent);
+        }
+        finish();
+    }
+
+    @Override // android.content.DialogInterface.OnCancelListener
+    public final void onCancel(@NonNull DialogInterface dialogInterface) {
+        this.zaa = 0;
+        setResult(0);
+        finish();
+    }
+
+    @Override // android.app.Activity
+    public final void onCreate(@Nullable 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(@NonNull Bundle bundle) {
+        bundle.putInt("resolution", this.zaa);
+        super.onSaveInstanceState(bundle);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/GoogleApiClient.java

@@ -0,0 +1,417 @@
+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 android.view.View;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.ArrayMap;
+import androidx.fragment.app.FragmentActivity;
+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.ClientSettings;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.signin.SignInOptions;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+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;
+
+@Deprecated
+/* loaded from: classes2.dex */
+public abstract class GoogleApiClient {
+
+    @NonNull
+    @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
+    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
+    public interface OnConnectionFailedListener extends com.google.android.gms.common.api.internal.OnConnectionFailedListener {
+    }
+
+    public static void dumpAll(@NonNull String str, @NonNull FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @NonNull 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;
+            }
+        }
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static Set<GoogleApiClient> getAllClients() {
+        Set<GoogleApiClient> set = zaa;
+        synchronized (set) {
+        }
+        return set;
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public abstract ConnectionResult blockingConnect();
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    public abstract ConnectionResult blockingConnect(long j, @NonNull TimeUnit timeUnit);
+
+    @NonNull
+    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(@NonNull String str, @NonNull FileDescriptor fileDescriptor, @NonNull PrintWriter printWriter, @NonNull String[] strArr);
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public <A extends Api.AnyClient, R extends Result, T extends BaseImplementation.ApiMethodImpl<R, A>> T enqueue(@NonNull T t) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public <A extends Api.AnyClient, T extends BaseImplementation.ApiMethodImpl<? extends Result, A>> T execute(@NonNull T t) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public <C extends Api.Client> C getClient(@NonNull Api.AnyClientKey<C> anyClientKey) {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    public abstract ConnectionResult getConnectionResult(@NonNull Api<?> api);
+
+    @NonNull
+    @KeepForSdk
+    public Context getContext() {
+        throw new UnsupportedOperationException();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public Looper getLooper() {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public boolean hasApi(@NonNull Api<?> api) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract boolean hasConnectedApi(@NonNull Api<?> api);
+
+    public abstract boolean isConnected();
+
+    public abstract boolean isConnecting();
+
+    public abstract boolean isConnectionCallbacksRegistered(@NonNull ConnectionCallbacks connectionCallbacks);
+
+    public abstract boolean isConnectionFailedListenerRegistered(@NonNull OnConnectionFailedListener onConnectionFailedListener);
+
+    @KeepForSdk
+    public boolean maybeSignIn(@NonNull SignInConnectionListener signInConnectionListener) {
+        throw new UnsupportedOperationException();
+    }
+
+    @KeepForSdk
+    public void maybeSignOut() {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract void reconnect();
+
+    public abstract void registerConnectionCallbacks(@NonNull ConnectionCallbacks connectionCallbacks);
+
+    public abstract void registerConnectionFailedListener(@NonNull OnConnectionFailedListener onConnectionFailedListener);
+
+    @NonNull
+    @KeepForSdk
+    public <L> ListenerHolder<L> registerListener(@NonNull L l) {
+        throw new UnsupportedOperationException();
+    }
+
+    public abstract void stopAutoManage(@NonNull FragmentActivity fragmentActivity);
+
+    public abstract void unregisterConnectionCallbacks(@NonNull ConnectionCallbacks connectionCallbacks);
+
+    public abstract void unregisterConnectionFailedListener(@NonNull OnConnectionFailedListener onConnectionFailedListener);
+
+    public void zao(zada zadaVar) {
+        throw new UnsupportedOperationException();
+    }
+
+    public void zap(zada zadaVar) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Deprecated
+    public static final class Builder {
+
+        @Nullable
+        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;
+
+        @Nullable
+        private OnConnectionFailedListener zam;
+        private Looper zan;
+        private GoogleApiAvailability zao;
+        private Api.AbstractClientBuilder zap;
+        private final ArrayList zaq;
+        private final ArrayList zar;
+
+        public Builder(@NonNull Context context) {
+            this.zab = new HashSet();
+            this.zac = new HashSet();
+            this.zah = new ArrayMap();
+            this.zaj = new ArrayMap();
+            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, @Nullable 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));
+        }
+
+        @NonNull
+        public Builder addApi(@NonNull 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;
+        }
+
+        @NonNull
+        public <O extends Api.ApiOptions.HasOptions> Builder addApiIfAvailable(@NonNull Api<O> api, @NonNull O o, @NonNull Scope... scopeArr) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            Preconditions.checkNotNull(o, "Null options are not permitted for this Api");
+            this.zaj.put(api, o);
+            zab(api, o, scopeArr);
+            return this;
+        }
+
+        @NonNull
+        public Builder addConnectionCallbacks(@NonNull ConnectionCallbacks connectionCallbacks) {
+            Preconditions.checkNotNull(connectionCallbacks, "Listener must not be null");
+            this.zaq.add(connectionCallbacks);
+            return this;
+        }
+
+        @NonNull
+        public Builder addOnConnectionFailedListener(@NonNull OnConnectionFailedListener onConnectionFailedListener) {
+            Preconditions.checkNotNull(onConnectionFailedListener, "Listener must not be null");
+            this.zar.add(onConnectionFailedListener);
+            return this;
+        }
+
+        @NonNull
+        public Builder addScope(@NonNull Scope scope) {
+            Preconditions.checkNotNull(scope, "Scope must not be null");
+            this.zab.add(scope);
+            return this;
+        }
+
+        @NonNull
+        @ResultIgnorabilityUnspecified
+        public GoogleApiClient build() {
+            Preconditions.checkArgument(!this.zaj.isEmpty(), "must call addApi() to add at least one API");
+            ClientSettings zaa = zaa();
+            Map zad = zaa.zad();
+            ArrayMap arrayMap = new ArrayMap();
+            ArrayMap arrayMap2 = new ArrayMap();
+            ArrayList arrayList = new ArrayList();
+            Api api = null;
+            boolean z = false;
+            for (Api api2 : this.zaj.keySet()) {
+                Object obj = this.zaj.get(api2);
+                boolean z2 = zad.get(api2) != null;
+                arrayMap.put(api2, Boolean.valueOf(z2));
+                zat zatVar = new zat(api2, z2);
+                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);
+                arrayMap2.put(api2.zab(), buildClient);
+                if (abstractClientBuilder.getPriority() == 1) {
+                    z = 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 (z) {
+                    throw new IllegalStateException("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, arrayMap, this.zaq, this.zar, arrayMap2, this.zal, zabe.zad(arrayMap2.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;
+        }
+
+        @NonNull
+        public Builder enableAutoManage(@NonNull FragmentActivity fragmentActivity, int i, @Nullable OnConnectionFailedListener onConnectionFailedListener) {
+            LifecycleActivity lifecycleActivity = new LifecycleActivity((Activity) fragmentActivity);
+            Preconditions.checkArgument(i >= 0, "clientId must be non-negative");
+            this.zal = i;
+            this.zam = onConnectionFailedListener;
+            this.zak = lifecycleActivity;
+            return this;
+        }
+
+        @NonNull
+        public Builder setAccountName(@NonNull String str) {
+            this.zaa = str == null ? null : new Account(str, "com.google");
+            return this;
+        }
+
+        @NonNull
+        public Builder setGravityForPopups(int i) {
+            this.zad = i;
+            return this;
+        }
+
+        @NonNull
+        public Builder setHandler(@NonNull Handler handler) {
+            Preconditions.checkNotNull(handler, "Handler must not be null");
+            this.zan = handler.getLooper();
+            return this;
+        }
+
+        @NonNull
+        public Builder setViewForPopups(@NonNull View view) {
+            Preconditions.checkNotNull(view, "View must not be null");
+            this.zae = view;
+            return this;
+        }
+
+        @NonNull
+        public Builder useDefaultAccount() {
+            setAccountName("<<default account>>");
+            return this;
+        }
+
+        @NonNull
+        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);
+        }
+
+        @NonNull
+        public Builder enableAutoManage(@NonNull FragmentActivity fragmentActivity, @Nullable OnConnectionFailedListener onConnectionFailedListener) {
+            enableAutoManage(fragmentActivity, 0, onConnectionFailedListener);
+            return this;
+        }
+
+        @NonNull
+        public <T extends Api.ApiOptions.NotRequiredOptions> Builder addApiIfAvailable(@NonNull Api<? extends Api.ApiOptions.NotRequiredOptions> api, @NonNull Scope... scopeArr) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            this.zaj.put(api, null);
+            zab(api, null, scopeArr);
+            return this;
+        }
+
+        @NonNull
+        public <O extends Api.ApiOptions.HasOptions> Builder addApi(@NonNull Api<O> api, @NonNull O o) {
+            Preconditions.checkNotNull(api, "Api must not be null");
+            Preconditions.checkNotNull(o, "Null options are not permitted for this Api");
+            this.zaj.put(api, o);
+            List<Scope> impliedScopes = ((Api.BaseClientBuilder) Preconditions.checkNotNull(api.zac(), "Base client builder must not be null")).getImpliedScopes(o);
+            this.zac.addAll(impliedScopes);
+            this.zab.addAll(impliedScopes);
+            return this;
+        }
+
+        public Builder(@NonNull Context context, @NonNull ConnectionCallbacks connectionCallbacks, @NonNull 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);
+        }
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/HasApiKey.java

@@ -0,0 +1,14 @@
+package com.google.android.gms.common.api;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Api;
+import com.google.android.gms.common.api.Api.ApiOptions;
+import com.google.android.gms.common.api.internal.ApiKey;
+
+/* loaded from: classes2.dex */
+public interface HasApiKey<O extends Api.ApiOptions> {
+    @NonNull
+    @KeepForSdk
+    ApiKey<O> getApiKey();
+}

decompiled-community/sources/com/google/android/gms/common/api/OptionalModuleApi.java

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

decompiled-community/sources/com/google/android/gms/common/api/OptionalPendingResult.java

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

decompiled-community/sources/com/google/android/gms/common/api/PendingResult.java

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

decompiled-community/sources/com/google/android/gms/common/api/PendingResults.java

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

decompiled-community/sources/com/google/android/gms/common/api/Releasable.java

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

decompiled-community/sources/com/google/android/gms/common/api/ResolvableApiException.java

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

decompiled-community/sources/com/google/android/gms/common/api/ResolvingResultCallbacks.java

@@ -0,0 +1,41 @@
+package com.google.android.gms.common.api;
+
+import android.app.Activity;
+import android.content.IntentSender;
+import android.util.Log;
+import androidx.annotation.NonNull;
+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: classes2.dex */
+public abstract class ResolvingResultCallbacks<R extends Result> extends ResultCallbacks<R> {
+    private final Activity zza;
+    private final int zzb;
+
+    public ResolvingResultCallbacks(@NonNull 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(@NonNull Status status) {
+        if (!status.hasResolution()) {
+            onUnresolvableFailure(status);
+            return;
+        }
+        try {
+            status.startResolutionForResult(this.zza, this.zzb);
+        } catch (IntentSender.SendIntentException e) {
+            Log.e("ResolvingResultCallback", "Failed to start resolution", e);
+            onUnresolvableFailure(new Status(8));
+        }
+    }
+
+    @Override // com.google.android.gms.common.api.ResultCallbacks
+    public abstract void onSuccess(@NonNull R r);
+
+    public abstract void onUnresolvableFailure(@NonNull Status status);
+}

decompiled-community/sources/com/google/android/gms/common/api/Response.java

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

decompiled-community/sources/com/google/android/gms/common/api/Result.java

@@ -0,0 +1,9 @@
+package com.google.android.gms.common.api;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes2.dex */
+public interface Result {
+    @NonNull
+    Status getStatus();
+}

decompiled-community/sources/com/google/android/gms/common/api/ResultCallback.java

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

decompiled-community/sources/com/google/android/gms/common/api/ResultCallbacks.java

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

decompiled-community/sources/com/google/android/gms/common/api/ResultTransform.java

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

decompiled-community/sources/com/google/android/gms/common/api/Scope.java

@@ -0,0 +1,71 @@
+package com.google.android.gms.common.api;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.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: classes2.dex */
+public final class Scope extends AbstractSafeParcelable implements ReflectedParcelable {
+
+    @NonNull
+    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(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof Scope) {
+            return this.zzb.equals(((Scope) obj).zzb);
+        }
+        return false;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public String getScopeUri() {
+        return this.zzb;
+    }
+
+    public int hashCode() {
+        return this.zzb.hashCode();
+    }
+
+    @NonNull
+    public String toString() {
+        return this.zzb;
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull Parcel parcel, int i) {
+        int i2 = this.zza;
+        int beginObjectHeader = SafeParcelWriter.beginObjectHeader(parcel);
+        SafeParcelWriter.writeInt(parcel, 1, i2);
+        SafeParcelWriter.writeString(parcel, 2, getScopeUri(), false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    public Scope(@NonNull String str) {
+        this(1, str);
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/Status.java

@@ -0,0 +1,206 @@
+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 androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.IntentSenderRequest;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+@SafeParcelable.Class(creator = "StatusCreator")
+/* loaded from: classes2.dex */
+public final class Status extends AbstractSafeParcelable implements Result, ReflectedParcelable {
+
+    @SafeParcelable.Field(getter = "getStatusCode", id = 1)
+    private final int zzb;
+
+    @Nullable
+    @SafeParcelable.Field(getter = "getStatusMessage", id = 2)
+    private final String zzc;
+
+    @Nullable
+    @SafeParcelable.Field(getter = "getPendingIntent", id = 3)
+    private final PendingIntent zzd;
+
+    @Nullable
+    @SafeParcelable.Field(getter = "getConnectionResult", id = 4)
+    private final ConnectionResult zze;
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_SUCCESS_CACHE = new Status(-1);
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_SUCCESS = new Status(0);
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_INTERRUPTED = new Status(14);
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_INTERNAL_ERROR = new Status(8);
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_TIMEOUT = new Status(15);
+
+    @NonNull
+    @ShowFirstParty
+    @KeepForSdk
+    public static final Status RESULT_CANCELED = new Status(16);
+
+    @NonNull
+    @ShowFirstParty
+    public static final Status zza = new Status(17);
+
+    @NonNull
+    @KeepForSdk
+    public static final Status RESULT_DEAD_CLIENT = new Status(18);
+
+    @NonNull
+    public static final Parcelable.Creator<Status> CREATOR = new zzb();
+
+    public Status(int i) {
+        this(i, (String) null);
+    }
+
+    @SafeParcelable.Constructor
+    public Status(@SafeParcelable.Param(id = 1) int i, @Nullable @SafeParcelable.Param(id = 2) String str, @Nullable @SafeParcelable.Param(id = 3) PendingIntent pendingIntent, @Nullable @SafeParcelable.Param(id = 4) ConnectionResult connectionResult) {
+        this.zzb = i;
+        this.zzc = str;
+        this.zzd = pendingIntent;
+        this.zze = connectionResult;
+    }
+
+    public Status(@NonNull ConnectionResult connectionResult, @NonNull String str) {
+        this(connectionResult, str, 17);
+    }
+
+    public boolean equals(@Nullable Object obj) {
+        if (!(obj instanceof Status)) {
+            return false;
+        }
+        Status status = (Status) obj;
+        return this.zzb == status.zzb && Objects.equal(this.zzc, status.zzc) && Objects.equal(this.zzd, status.zzd) && Objects.equal(this.zze, status.zze);
+    }
+
+    @Nullable
+    public ConnectionResult getConnectionResult() {
+        return this.zze;
+    }
+
+    @Nullable
+    public PendingIntent getResolution() {
+        return this.zzd;
+    }
+
+    @Override // com.google.android.gms.common.api.Result
+    @NonNull
+    public Status getStatus() {
+        return this;
+    }
+
+    @ResultIgnorabilityUnspecified
+    public int getStatusCode() {
+        return this.zzb;
+    }
+
+    @Nullable
+    public String getStatusMessage() {
+        return this.zzc;
+    }
+
+    public boolean hasResolution() {
+        return this.zzd != null;
+    }
+
+    public int hashCode() {
+        return Objects.hashCode(Integer.valueOf(this.zzb), this.zzc, this.zzd, this.zze);
+    }
+
+    public boolean isCanceled() {
+        return this.zzb == 16;
+    }
+
+    public boolean isInterrupted() {
+        return this.zzb == 14;
+    }
+
+    public boolean isSuccess() {
+        return this.zzb <= 0;
+    }
+
+    public void startResolutionForResult(@NonNull Activity activity, int i) throws IntentSender.SendIntentException {
+        if (hasResolution()) {
+            PendingIntent pendingIntent = this.zzd;
+            Preconditions.checkNotNull(pendingIntent);
+            activity.startIntentSenderForResult(pendingIntent.getIntentSender(), i, null, 0, 0, 0);
+        }
+    }
+
+    @NonNull
+    public String toString() {
+        Objects.ToStringHelper stringHelper = Objects.toStringHelper(this);
+        stringHelper.add("statusCode", zza());
+        stringHelper.add("resolution", this.zzd);
+        return stringHelper.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(@NonNull 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.zzd, i, false);
+        SafeParcelWriter.writeParcelable(parcel, 4, getConnectionResult(), i, false);
+        SafeParcelWriter.finishObjectHeader(parcel, beginObjectHeader);
+    }
+
+    @NonNull
+    public final String zza() {
+        String str = this.zzc;
+        return str != null ? str : CommonStatusCodes.getStatusCodeString(this.zzb);
+    }
+
+    public Status(int i, @Nullable String str) {
+        this(i, str, (PendingIntent) null);
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public Status(@NonNull ConnectionResult connectionResult, @NonNull String str, int i) {
+        this(i, str, connectionResult.getResolution(), connectionResult);
+    }
+
+    public Status(int i, @Nullable String str, @Nullable PendingIntent pendingIntent) {
+        this(i, str, pendingIntent, null);
+    }
+
+    public void startResolutionForResult(@NonNull ActivityResultLauncher<IntentSenderRequest> activityResultLauncher) {
+        if (hasResolution()) {
+            PendingIntent pendingIntent = this.zzd;
+            Preconditions.checkNotNull(pendingIntent);
+            activityResultLauncher.launch(new IntentSenderRequest.Builder(pendingIntent.getIntentSender()).build());
+        }
+    }
+}

decompiled-community/sources/com/google/android/gms/common/api/TransformedResult.java

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

decompiled-community/sources/com/google/android/gms/common/api/UnsupportedApiCallException.java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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