Add decompiled APK source code (JADX)

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

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

decompiled/sources/com/google/android/gms/common/util/AndroidUtilsLight.java

@@ -0,0 +1,48 @@
+package com.google.android.gms.common.util;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.Signature;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+import com.google.android.gms.common.wrappers.Wrappers;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class AndroidUtilsLight {
+    private static volatile int zza = -1;
+
+    @Nullable
+    @KeepForSdk
+    @Deprecated
+    public static byte[] getPackageCertificateHashBytes(@NonNull Context context, @NonNull String str) throws PackageManager.NameNotFoundException {
+        MessageDigest zza2;
+        PackageInfo packageInfo = Wrappers.packageManager(context).getPackageInfo(str, 64);
+        Signature[] signatureArr = packageInfo.signatures;
+        if (signatureArr == null || signatureArr.length != 1 || (zza2 = zza("SHA1")) == null) {
+            return null;
+        }
+        return zza2.digest(packageInfo.signatures[0].toByteArray());
+    }
+
+    @Nullable
+    public static MessageDigest zza(@NonNull String str) {
+        MessageDigest messageDigest;
+        for (int i = 0; i < 2; i++) {
+            try {
+                messageDigest = MessageDigest.getInstance(str);
+            } catch (NoSuchAlgorithmException unused) {
+            }
+            if (messageDigest != null) {
+                return messageDigest;
+            }
+        }
+        return null;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/ArrayUtils.java

@@ -0,0 +1,251 @@
+package com.google.android.gms.common.util;
+
+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 java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class ArrayUtils {
+    private ArrayUtils() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T> T[] concat(@NonNull T[]... tArr) {
+        if (tArr.length == 0) {
+            return (T[]) ((Object[]) Array.newInstance(tArr.getClass(), 0));
+        }
+        int i = 0;
+        for (T[] tArr2 : tArr) {
+            i += tArr2.length;
+        }
+        T[] tArr3 = (T[]) Arrays.copyOf(tArr[0], i);
+        int length = tArr[0].length;
+        for (int i2 = 1; i2 < tArr.length; i2++) {
+            T[] tArr4 = tArr[i2];
+            int length2 = tArr4.length;
+            System.arraycopy(tArr4, 0, tArr3, length, length2);
+            length += length2;
+        }
+        return tArr3;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static byte[] concatByteArrays(@NonNull byte[]... bArr) {
+        if (bArr.length == 0) {
+            return new byte[0];
+        }
+        int i = 0;
+        for (byte[] bArr2 : bArr) {
+            i += bArr2.length;
+        }
+        byte[] copyOf = Arrays.copyOf(bArr[0], i);
+        int length = bArr[0].length;
+        for (int i2 = 1; i2 < bArr.length; i2++) {
+            byte[] bArr3 = bArr[i2];
+            int length2 = bArr3.length;
+            System.arraycopy(bArr3, 0, copyOf, length, length2);
+            length += length2;
+        }
+        return copyOf;
+    }
+
+    @KeepForSdk
+    public static boolean contains(@Nullable int[] iArr, int i) {
+        if (iArr != null) {
+            for (int i2 : iArr) {
+                if (i2 == i) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T> ArrayList<T> newArrayList() {
+        return new ArrayList<>();
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static <T> T[] removeAll(@NonNull T[] tArr, @NonNull T... tArr2) {
+        int length;
+        int i;
+        if (tArr == null) {
+            return null;
+        }
+        if (tArr2 == null || (length = tArr2.length) == 0) {
+            return (T[]) Arrays.copyOf(tArr, tArr.length);
+        }
+        Class<?> cls = tArr2.getClass();
+        T[] tArr3 = (T[]) ((Object[]) Array.newInstance(cls.getComponentType(), tArr.length));
+        if (length == 1) {
+            i = 0;
+            for (T t : tArr) {
+                if (!Objects.equal(tArr2[0], t)) {
+                    tArr3[i] = t;
+                    i++;
+                }
+            }
+        } else {
+            int i2 = 0;
+            for (T t2 : tArr) {
+                if (!contains(tArr2, t2)) {
+                    tArr3[i2] = t2;
+                    i2++;
+                }
+            }
+            i = i2;
+        }
+        if (tArr3 == null) {
+            return null;
+        }
+        return i == tArr3.length ? tArr3 : (T[]) Arrays.copyOf(tArr3, i);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T> ArrayList<T> toArrayList(@NonNull T[] tArr) {
+        ArrayList<T> arrayList = new ArrayList<>(tArr.length);
+        for (T t : tArr) {
+            arrayList.add(t);
+        }
+        return arrayList;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static int[] toPrimitiveArray(@Nullable Collection<Integer> collection) {
+        int i = 0;
+        if (collection == null || collection.isEmpty()) {
+            return new int[0];
+        }
+        int[] iArr = new int[collection.size()];
+        Iterator<Integer> it = collection.iterator();
+        while (it.hasNext()) {
+            iArr[i] = it.next().intValue();
+            i++;
+        }
+        return iArr;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static Integer[] toWrapperArray(@Nullable int[] iArr) {
+        if (iArr == null) {
+            return null;
+        }
+        int length = iArr.length;
+        Integer[] numArr = new Integer[length];
+        for (int i = 0; i < length; i++) {
+            numArr[i] = Integer.valueOf(iArr[i]);
+        }
+        return numArr;
+    }
+
+    @KeepForSdk
+    public static void writeArray(@NonNull StringBuilder sb, @NonNull double[] dArr) {
+        int length = dArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append(dArr[i]);
+        }
+    }
+
+    @KeepForSdk
+    public static void writeStringArray(@NonNull StringBuilder sb, @NonNull String[] strArr) {
+        int length = strArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append("\"");
+            sb.append(strArr[i]);
+            sb.append("\"");
+        }
+    }
+
+    @KeepForSdk
+    public static <T> boolean contains(@NonNull T[] tArr, @Nullable T t) {
+        int length = tArr != null ? tArr.length : 0;
+        int i = 0;
+        while (true) {
+            if (i >= length) {
+                break;
+            }
+            if (!Objects.equal(tArr[i], t)) {
+                i++;
+            } else if (i >= 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    public static void writeArray(@NonNull StringBuilder sb, @NonNull float[] fArr) {
+        int length = fArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append(fArr[i]);
+        }
+    }
+
+    @KeepForSdk
+    public static void writeArray(@NonNull StringBuilder sb, @NonNull int[] iArr) {
+        int length = iArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append(iArr[i]);
+        }
+    }
+
+    @KeepForSdk
+    public static void writeArray(@NonNull StringBuilder sb, @NonNull long[] jArr) {
+        int length = jArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append(jArr[i]);
+        }
+    }
+
+    @KeepForSdk
+    public static <T> void writeArray(@NonNull StringBuilder sb, @NonNull T[] tArr) {
+        int length = tArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append(tArr[i]);
+        }
+    }
+
+    @KeepForSdk
+    public static void writeArray(@NonNull StringBuilder sb, @NonNull boolean[] zArr) {
+        int length = zArr.length;
+        for (int i = 0; i < length; i++) {
+            if (i != 0) {
+                sb.append(",");
+            }
+            sb.append(zArr[i]);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/util/Base64Utils.java

@@ -0,0 +1,65 @@
+package com.google.android.gms.common.util;
+
+import android.util.Base64;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class Base64Utils {
+    @NonNull
+    @KeepForSdk
+    public static byte[] decode(@NonNull String str) {
+        if (str == null) {
+            return null;
+        }
+        return Base64.decode(str, 0);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static byte[] decodeUrlSafe(@NonNull String str) {
+        if (str == null) {
+            return null;
+        }
+        return Base64.decode(str, 10);
+    }
+
+    @NonNull
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public static byte[] decodeUrlSafeNoPadding(@NonNull String str) {
+        if (str == null) {
+            return null;
+        }
+        return Base64.decode(str, 11);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String encode(@NonNull byte[] bArr) {
+        if (bArr == null) {
+            return null;
+        }
+        return Base64.encodeToString(bArr, 0);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String encodeUrlSafe(@NonNull byte[] bArr) {
+        if (bArr == null) {
+            return null;
+        }
+        return Base64.encodeToString(bArr, 10);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String encodeUrlSafeNoPadding(@NonNull byte[] bArr) {
+        if (bArr == null) {
+            return null;
+        }
+        return Base64.encodeToString(bArr, 11);
+    }
+}

decompiled/sources/com/google/android/gms/common/util/BiConsumer.java

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

decompiled/sources/com/google/android/gms/common/util/ClientLibraryUtils.java

@@ -0,0 +1,44 @@
+package com.google.android.gms.common.util;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+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.wrappers.Wrappers;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class ClientLibraryUtils {
+    private ClientLibraryUtils() {
+    }
+
+    @KeepForSdk
+    public static int getClientVersion(@NonNull Context context, @NonNull String str) {
+        ApplicationInfo applicationInfo;
+        Bundle bundle;
+        PackageInfo packageInfo = getPackageInfo(context, str);
+        if (packageInfo == null || (applicationInfo = packageInfo.applicationInfo) == null || (bundle = applicationInfo.metaData) == null) {
+            return -1;
+        }
+        return bundle.getInt("com.google.android.gms.version", -1);
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static PackageInfo getPackageInfo(@NonNull Context context, @NonNull String str) {
+        try {
+            return Wrappers.packageManager(context).getPackageInfo(str, 128);
+        } catch (PackageManager.NameNotFoundException unused) {
+            return null;
+        }
+    }
+
+    @KeepForSdk
+    public static boolean isPackageSide() {
+        return false;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/Clock.java

@@ -0,0 +1,26 @@
+package com.google.android.gms.common.util;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface Clock {
+
+    /* renamed from: com.google.android.gms.common.util.Clock$-CC, reason: invalid class name */
+    public final /* synthetic */ class CC {
+    }
+
+    @KeepForSdk
+    long currentThreadTimeMillis();
+
+    @KeepForSdk
+    long currentTimeMillis();
+
+    @KeepForSdk
+    long elapsedRealtime();
+
+    @KeepForSdk
+    long nanoTime();
+}

decompiled/sources/com/google/android/gms/common/util/CollectionUtils.java

@@ -0,0 +1,169 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.ArrayMap;
+import androidx.collection.ArraySet;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class CollectionUtils {
+    private CollectionUtils() {
+    }
+
+    @KeepForSdk
+    public static boolean isEmpty(@Nullable Collection<?> collection) {
+        if (collection == null) {
+            return true;
+        }
+        return collection.isEmpty();
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static <T> List<T> listOf() {
+        return Collections.emptyList();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <K, V> Map<K, V> mapOf(@NonNull K k, @NonNull V v, @NonNull K k2, @NonNull V v2, @NonNull K k3, @NonNull V v3) {
+        Map zza = zza(3, false);
+        zza.put(k, v);
+        zza.put(k2, v2);
+        zza.put(k3, v3);
+        return Collections.unmodifiableMap(zza);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <K, V> Map<K, V> mapOfKeyValueArrays(@NonNull K[] kArr, @NonNull V[] vArr) {
+        int length = kArr.length;
+        int length2 = vArr.length;
+        if (length != length2) {
+            throw new IllegalArgumentException("Key and values array lengths not equal: " + length + " != " + length2);
+        }
+        if (length == 0) {
+            return Collections.emptyMap();
+        }
+        if (length == 1) {
+            return Collections.singletonMap(kArr[0], vArr[0]);
+        }
+        Map zza = zza(length, false);
+        for (int i = 0; i < kArr.length; i++) {
+            zza.put(kArr[i], vArr[i]);
+        }
+        return Collections.unmodifiableMap(zza);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <T> Set<T> mutableSetOfWithSize(int i) {
+        return i == 0 ? new ArraySet() : zzb(i, true);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static <T> Set<T> setOf(@NonNull T t, @NonNull T t2, @NonNull T t3) {
+        Set zzb = zzb(3, false);
+        zzb.add(t);
+        zzb.add(t2);
+        zzb.add(t3);
+        return Collections.unmodifiableSet(zzb);
+    }
+
+    private static Map zza(int i, boolean z) {
+        return i <= 256 ? new ArrayMap(i) : new HashMap(i, 1.0f);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static <T> List<T> listOf(@NonNull T t) {
+        return Collections.singletonList(t);
+    }
+
+    private static Set zzb(int i, boolean z) {
+        if (i <= (true != z ? 256 : 128)) {
+            return new ArraySet(i);
+        }
+        return new HashSet(i, true != z ? 1.0f : 0.75f);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static <T> List<T> listOf(@NonNull T... tArr) {
+        int length = tArr.length;
+        if (length == 0) {
+            return Collections.emptyList();
+        }
+        if (length == 1) {
+            return Collections.singletonList(tArr[0]);
+        }
+        return Collections.unmodifiableList(Arrays.asList(tArr));
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static <K, V> Map<K, V> mapOf(@NonNull K k, @NonNull V v, @NonNull K k2, @NonNull V v2, @NonNull K k3, @NonNull V v3, @NonNull K k4, @NonNull V v4, @NonNull K k5, @NonNull V v5, @NonNull K k6, @NonNull V v6) {
+        Map zza = zza(6, false);
+        zza.put(k, v);
+        zza.put(k2, v2);
+        zza.put(k3, v3);
+        zza.put(k4, v4);
+        zza.put(k5, v5);
+        zza.put(k6, v6);
+        return Collections.unmodifiableMap(zza);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static <T> Set<T> setOf(@NonNull T... tArr) {
+        int length = tArr.length;
+        if (length == 0) {
+            return Collections.emptySet();
+        }
+        if (length == 1) {
+            return Collections.singleton(tArr[0]);
+        }
+        if (length == 2) {
+            T t = tArr[0];
+            T t2 = tArr[1];
+            Set zzb = zzb(2, false);
+            zzb.add(t);
+            zzb.add(t2);
+            return Collections.unmodifiableSet(zzb);
+        }
+        if (length == 3) {
+            return setOf(tArr[0], tArr[1], tArr[2]);
+        }
+        if (length == 4) {
+            T t3 = tArr[0];
+            T t4 = tArr[1];
+            T t5 = tArr[2];
+            T t6 = tArr[3];
+            Set zzb2 = zzb(4, false);
+            zzb2.add(t3);
+            zzb2.add(t4);
+            zzb2.add(t5);
+            zzb2.add(t6);
+            return Collections.unmodifiableSet(zzb2);
+        }
+        Set zzb3 = zzb(length, false);
+        Collections.addAll(zzb3, tArr);
+        return Collections.unmodifiableSet(zzb3);
+    }
+}

decompiled/sources/com/google/android/gms/common/util/CrashUtils.java

@@ -0,0 +1,27 @@
+package com.google.android.gms.common.util;
+
+import android.content.Context;
+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.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class CrashUtils {
+    private static final String[] zza = {"android.", "com.android.", "dalvik.", "java.", "javax."};
+
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public static boolean addDynamiteErrorToDropBox(@NonNull Context context, @NonNull Throwable th) {
+        try {
+            Preconditions.checkNotNull(context);
+            Preconditions.checkNotNull(th);
+            return false;
+        } catch (Exception e) {
+            Log.e("CrashUtils", "Error adding exception to DropBox!", e);
+            return false;
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/util/DataUtils.java

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.util;
+
+import android.database.CharArrayBuffer;
+import android.graphics.Bitmap;
+import android.text.TextUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import java.io.ByteArrayOutputStream;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class DataUtils {
+    @KeepForSdk
+    public static void copyStringToBuffer(@Nullable String str, @NonNull CharArrayBuffer charArrayBuffer) {
+        if (TextUtils.isEmpty(str)) {
+            charArrayBuffer.sizeCopied = 0;
+            return;
+        }
+        char[] cArr = charArrayBuffer.data;
+        if (cArr == null || cArr.length < str.length()) {
+            charArrayBuffer.data = str.toCharArray();
+        } else {
+            str.getChars(0, str.length(), charArrayBuffer.data, 0);
+        }
+        charArrayBuffer.sizeCopied = str.length();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static byte[] loadImageBytes(@NonNull Bitmap bitmap) {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, byteArrayOutputStream);
+        return byteArrayOutputStream.toByteArray();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/DefaultClock.java

@@ -0,0 +1,40 @@
+package com.google.android.gms.common.util;
+
+import android.os.SystemClock;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class DefaultClock implements Clock {
+    private static final DefaultClock zza = new DefaultClock();
+
+    private DefaultClock() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static Clock getInstance() {
+        return zza;
+    }
+
+    @Override // com.google.android.gms.common.util.Clock
+    public final long currentThreadTimeMillis() {
+        return SystemClock.currentThreadTimeMillis();
+    }
+
+    @Override // com.google.android.gms.common.util.Clock
+    public final long currentTimeMillis() {
+        return System.currentTimeMillis();
+    }
+
+    @Override // com.google.android.gms.common.util.Clock
+    public final long elapsedRealtime() {
+        return SystemClock.elapsedRealtime();
+    }
+
+    @Override // com.google.android.gms.common.util.Clock
+    public final long nanoTime() {
+        return System.nanoTime();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/DeviceProperties.java

@@ -0,0 +1,307 @@
+package com.google.android.gms.common.util;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.hardware.SensorManager;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.apps.common.proguard.SideEffectFree;
+import com.google.android.gms.common.GooglePlayServicesUtilLight;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class DeviceProperties {
+
+    @Nullable
+    private static Boolean zza;
+
+    @Nullable
+    private static Boolean zzb;
+
+    @Nullable
+    private static Boolean zzc;
+
+    @Nullable
+    private static Boolean zzd;
+
+    @Nullable
+    private static Boolean zze;
+
+    @Nullable
+    private static Boolean zzf;
+
+    @Nullable
+    private static Boolean zzg;
+
+    @Nullable
+    private static Boolean zzh;
+
+    @Nullable
+    private static Boolean zzi;
+
+    @Nullable
+    private static Boolean zzj;
+
+    @Nullable
+    private static Boolean zzk;
+
+    @Nullable
+    private static Boolean zzl;
+
+    @Nullable
+    private static Boolean zzm;
+
+    @Nullable
+    private static Boolean zzn;
+
+    private DeviceProperties() {
+    }
+
+    @KeepForSdk
+    public static boolean isAuto(@NonNull Context context) {
+        PackageManager packageManager = context.getPackageManager();
+        if (zzj == null) {
+            boolean z = false;
+            if (PlatformVersion.isAtLeastO() && packageManager.hasSystemFeature("android.hardware.type.automotive")) {
+                z = true;
+            }
+            zzj = Boolean.valueOf(z);
+        }
+        return zzj.booleanValue();
+    }
+
+    @KeepForSdk
+    public static boolean isBstar(@NonNull Context context) {
+        if (zzm == null) {
+            boolean z = false;
+            if (PlatformVersion.isAtLeastR() && context.getPackageManager().hasSystemFeature("com.google.android.play.feature.HPE_EXPERIENCE")) {
+                z = true;
+            }
+            zzm = Boolean.valueOf(z);
+        }
+        return zzm.booleanValue();
+    }
+
+    @KeepForSdk
+    public static boolean isFoldable(@NonNull Context context) {
+        if (zzc == null) {
+            SensorManager sensorManager = (SensorManager) context.getSystemService("sensor");
+            boolean z = false;
+            if (PlatformVersion.isAtLeastR() && sensorManager != null && sensorManager.getDefaultSensor(36) != null) {
+                z = true;
+            }
+            zzc = Boolean.valueOf(z);
+        }
+        return zzc.booleanValue();
+    }
+
+    @KeepForSdk
+    public static boolean isLatchsky(@NonNull Context context) {
+        if (zzg == null) {
+            PackageManager packageManager = context.getPackageManager();
+            boolean z = false;
+            if (packageManager.hasSystemFeature("com.google.android.feature.services_updater") && packageManager.hasSystemFeature("cn.google.services")) {
+                z = true;
+            }
+            zzg = Boolean.valueOf(z);
+        }
+        return zzg.booleanValue();
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:28:0x006c, code lost:
+    
+        if (isXr(r4) == false) goto L32;
+     */
+    @com.google.android.gms.common.annotation.KeepForSdk
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static boolean isPhone(@androidx.annotation.NonNull android.content.Context r4) {
+        /*
+            java.lang.Boolean r0 = com.google.android.gms.common.util.DeviceProperties.zza
+            if (r0 != 0) goto L76
+            boolean r0 = isFoldable(r4)
+            r1 = 1
+            if (r0 != 0) goto L70
+            boolean r0 = isTablet(r4)
+            r2 = 0
+            if (r0 != 0) goto L6f
+            boolean r0 = isWearable(r4)
+            if (r0 != 0) goto L6f
+            boolean r0 = zzb(r4)
+            if (r0 != 0) goto L6f
+            java.lang.Boolean r0 = com.google.android.gms.common.util.DeviceProperties.zzi
+            if (r0 != 0) goto L32
+            android.content.pm.PackageManager r0 = r4.getPackageManager()
+            java.lang.String r3 = "org.chromium.arc"
+            boolean r0 = r0.hasSystemFeature(r3)
+            java.lang.Boolean r0 = java.lang.Boolean.valueOf(r0)
+            com.google.android.gms.common.util.DeviceProperties.zzi = r0
+        L32:
+            java.lang.Boolean r0 = com.google.android.gms.common.util.DeviceProperties.zzi
+            boolean r0 = r0.booleanValue()
+            if (r0 != 0) goto L6f
+            boolean r0 = isAuto(r4)
+            if (r0 != 0) goto L6f
+            boolean r0 = isTv(r4)
+            if (r0 != 0) goto L6f
+            java.lang.Boolean r0 = com.google.android.gms.common.util.DeviceProperties.zzl
+            if (r0 != 0) goto L5a
+            android.content.pm.PackageManager r0 = r4.getPackageManager()
+            java.lang.String r3 = "com.google.android.feature.AMATI_EXPERIENCE"
+            boolean r0 = r0.hasSystemFeature(r3)
+            java.lang.Boolean r0 = java.lang.Boolean.valueOf(r0)
+            com.google.android.gms.common.util.DeviceProperties.zzl = r0
+        L5a:
+            java.lang.Boolean r0 = com.google.android.gms.common.util.DeviceProperties.zzl
+            boolean r0 = r0.booleanValue()
+            if (r0 != 0) goto L6f
+            boolean r0 = isBstar(r4)
+            if (r0 != 0) goto L6f
+            boolean r4 = isXr(r4)
+            if (r4 != 0) goto L6f
+            goto L70
+        L6f:
+            r1 = r2
+        L70:
+            java.lang.Boolean r4 = java.lang.Boolean.valueOf(r1)
+            com.google.android.gms.common.util.DeviceProperties.zza = r4
+        L76:
+            java.lang.Boolean r4 = com.google.android.gms.common.util.DeviceProperties.zza
+            boolean r4 = r4.booleanValue()
+            return r4
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.util.DeviceProperties.isPhone(android.content.Context):boolean");
+    }
+
+    @KeepForSdk
+    public static boolean isSevenInchTablet(@NonNull Context context) {
+        return zzc(context.getResources());
+    }
+
+    @KeepForSdk
+    @TargetApi(21)
+    public static boolean isSidewinder(@NonNull Context context) {
+        return zza(context);
+    }
+
+    @KeepForSdk
+    public static boolean isTablet(@NonNull Context context) {
+        return isTablet(context.getResources());
+    }
+
+    @KeepForSdk
+    public static boolean isTv(@NonNull Context context) {
+        PackageManager packageManager = context.getPackageManager();
+        if (zzk == null) {
+            boolean z = true;
+            if (!packageManager.hasSystemFeature("com.google.android.tv") && !packageManager.hasSystemFeature("android.hardware.type.television") && !packageManager.hasSystemFeature("android.software.leanback")) {
+                z = false;
+            }
+            zzk = Boolean.valueOf(z);
+        }
+        return zzk.booleanValue();
+    }
+
+    @KeepForSdk
+    public static boolean isUserBuild() {
+        int i = GooglePlayServicesUtilLight.GOOGLE_PLAY_SERVICES_VERSION_CODE;
+        return "user".equals(Build.TYPE);
+    }
+
+    @SideEffectFree
+    @KeepForSdk
+    @TargetApi(20)
+    public static boolean isWearable(@NonNull Context context) {
+        return zzd(context.getPackageManager());
+    }
+
+    @KeepForSdk
+    @TargetApi(26)
+    public static boolean isWearableWithoutPlayStore(@NonNull Context context) {
+        if (isWearable(context) && !PlatformVersion.isAtLeastN()) {
+            return true;
+        }
+        if (zza(context)) {
+            return !PlatformVersion.isAtLeastO() || PlatformVersion.isAtLeastR();
+        }
+        return false;
+    }
+
+    @KeepForSdk
+    public static boolean isXr(@NonNull Context context) {
+        PackageManager packageManager = context.getPackageManager();
+        if (zzn == null) {
+            zzn = Boolean.valueOf(packageManager.hasSystemFeature("android.software.xr.immersive"));
+        }
+        return zzn.booleanValue();
+    }
+
+    @TargetApi(21)
+    public static boolean zza(@NonNull Context context) {
+        if (zzf == null) {
+            boolean z = false;
+            if (PlatformVersion.isAtLeastLollipop() && context.getPackageManager().hasSystemFeature("cn.google")) {
+                z = true;
+            }
+            zzf = Boolean.valueOf(z);
+        }
+        return zzf.booleanValue();
+    }
+
+    public static boolean zzb(@NonNull Context context) {
+        if (zzh == null) {
+            boolean z = true;
+            if (!context.getPackageManager().hasSystemFeature("android.hardware.type.iot") && !context.getPackageManager().hasSystemFeature("android.hardware.type.embedded")) {
+                z = false;
+            }
+            zzh = Boolean.valueOf(z);
+        }
+        return zzh.booleanValue();
+    }
+
+    public static boolean zzc(@NonNull Resources resources) {
+        boolean z = false;
+        if (resources == null) {
+            return false;
+        }
+        if (zzd == null) {
+            Configuration configuration = resources.getConfiguration();
+            if ((configuration.screenLayout & 15) <= 3 && configuration.smallestScreenWidthDp >= 600) {
+                z = true;
+            }
+            zzd = Boolean.valueOf(z);
+        }
+        return zzd.booleanValue();
+    }
+
+    @SideEffectFree
+    @TargetApi(20)
+    public static boolean zzd(@NonNull PackageManager packageManager) {
+        if (zze == null) {
+            boolean z = false;
+            if (PlatformVersion.isAtLeastKitKatWatch() && packageManager.hasSystemFeature("android.hardware.type.watch")) {
+                z = true;
+            }
+            zze = Boolean.valueOf(z);
+        }
+        return zze.booleanValue();
+    }
+
+    @KeepForSdk
+    public static boolean isTablet(@NonNull Resources resources) {
+        if (resources == null) {
+            return false;
+        }
+        if (zzb == null) {
+            zzb = Boolean.valueOf((resources.getConfiguration().screenLayout & 15) > 3 || zzc(resources));
+        }
+        return zzb.booleanValue();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/DynamiteApi.java

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

decompiled/sources/com/google/android/gms/common/util/GmsVersion.java

@@ -0,0 +1,46 @@
+package com.google.android.gms.common.util;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class GmsVersion {
+
+    @KeepForSdk
+    public static final int VERSION_HALLOUMI = 4100000;
+
+    @KeepForSdk
+    public static final int VERSION_JARLSBERG = 4300000;
+
+    @KeepForSdk
+    public static final int VERSION_KENAFA = 4400000;
+
+    @KeepForSdk
+    public static final int VERSION_LONGHORN = 5000000;
+
+    @KeepForSdk
+    public static final int VERSION_MANCHEGO = 6000000;
+
+    @KeepForSdk
+    public static final int VERSION_ORLA = 7000000;
+
+    @KeepForSdk
+    public static final int VERSION_PARMESAN = 7200000;
+
+    @KeepForSdk
+    public static final int VERSION_QUESO = 7500000;
+
+    @KeepForSdk
+    public static final int VERSION_REBLOCHON = 7800000;
+
+    @KeepForSdk
+    public static final int VERSION_SAGA = 8000000;
+
+    private GmsVersion() {
+    }
+
+    @KeepForSdk
+    public static boolean isAtLeastFenacho(int i) {
+        return i >= 3200000;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/Hex.java

@@ -0,0 +1,65 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import com.applovin.exoplayer2.common.base.Ascii;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.ShowFirstParty;
+
+@ShowFirstParty
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class Hex {
+    private static final char[] zza = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+    private static final char[] zzb = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    @NonNull
+    @KeepForSdk
+    public static String bytesToStringLowercase(@NonNull byte[] bArr) {
+        int length = bArr.length;
+        char[] cArr = new char[length + length];
+        int i = 0;
+        for (byte b : bArr) {
+            char[] cArr2 = zzb;
+            cArr[i] = cArr2[(b & 255) >>> 4];
+            cArr[i + 1] = cArr2[b & Ascii.SI];
+            i += 2;
+        }
+        return new String(cArr);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String bytesToStringUppercase(@NonNull byte[] bArr) {
+        return bytesToStringUppercase(bArr, false);
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static byte[] stringToBytes(@NonNull String str) throws IllegalArgumentException {
+        int length = str.length();
+        if (length % 2 != 0) {
+            throw new IllegalArgumentException("Hex string has odd number of characters");
+        }
+        byte[] bArr = new byte[length / 2];
+        int i = 0;
+        while (i < length) {
+            int i2 = i + 2;
+            bArr[i / 2] = (byte) Integer.parseInt(str.substring(i, i2), 16);
+            i = i2;
+        }
+        return bArr;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String bytesToStringUppercase(@NonNull byte[] bArr, boolean z) {
+        int length = bArr.length;
+        StringBuilder sb = new StringBuilder(length + length);
+        for (int i = 0; i < length && (!z || i != length - 1 || (bArr[i] & 255) != 0); i++) {
+            char[] cArr = zza;
+            sb.append(cArr[(bArr[i] & 240) >>> 4]);
+            sb.append(cArr[bArr[i] & Ascii.SI]);
+        }
+        return sb.toString();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/HexDumpUtils.java

@@ -0,0 +1,64 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.errorprone.annotations.ResultIgnorabilityUnspecified;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class HexDumpUtils {
+    @Nullable
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    public static String dump(@NonNull byte[] bArr, int i, int i2, boolean z) {
+        int length;
+        if (bArr == null || (length = bArr.length) == 0 || i < 0 || i2 <= 0 || i + i2 > length) {
+            return null;
+        }
+        StringBuilder sb = new StringBuilder((z ? 75 : 57) * ((i2 + 15) / 16));
+        int i3 = i2;
+        int i4 = 0;
+        int i5 = 0;
+        while (i3 > 0) {
+            if (i4 == 0) {
+                if (i2 < 65536) {
+                    sb.append(String.format("%04X:", Integer.valueOf(i)));
+                } else {
+                    sb.append(String.format("%08X:", Integer.valueOf(i)));
+                }
+                i5 = i;
+            } else if (i4 == 8) {
+                sb.append(" -");
+            }
+            sb.append(String.format(" %02X", Integer.valueOf(bArr[i] & 255)));
+            i3--;
+            i4++;
+            if (z && (i4 == 16 || i3 == 0)) {
+                int i6 = 16 - i4;
+                if (i6 > 0) {
+                    for (int i7 = 0; i7 < i6; i7++) {
+                        sb.append("   ");
+                    }
+                }
+                if (i6 >= 8) {
+                    sb.append("  ");
+                }
+                sb.append("  ");
+                for (int i8 = 0; i8 < i4; i8++) {
+                    char c = (char) bArr[i5 + i8];
+                    if (c < ' ' || c > '~') {
+                        c = '.';
+                    }
+                    sb.append(c);
+                }
+            }
+            if (i4 == 16 || i3 == 0) {
+                sb.append('\n');
+                i4 = 0;
+            }
+            i++;
+        }
+        return sb.toString();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/HttpUtils.java

@@ -0,0 +1,58 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.internal.common.zzo;
+import com.google.android.gms.internal.common.zzx;
+import com.ironsource.nb;
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URLDecoder;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class HttpUtils {
+    private static final Pattern zza = Pattern.compile("^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$");
+    private static final Pattern zzb = Pattern.compile("^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$");
+    private static final Pattern zzc = Pattern.compile("^((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)::((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)$");
+
+    private HttpUtils() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static Map<String, String> parse(@NonNull URI uri, @NonNull String str) {
+        Map<String, String> emptyMap = Collections.emptyMap();
+        String rawQuery = uri.getRawQuery();
+        if (rawQuery != null && rawQuery.length() > 0) {
+            emptyMap = new HashMap<>();
+            zzx zzc2 = zzx.zzc(zzo.zzb(nb.T));
+            Iterator it = zzx.zzc(zzo.zzb('&')).zzb().zzd(rawQuery).iterator();
+            while (it.hasNext()) {
+                List zzf = zzc2.zzf((String) it.next());
+                if (zzf.isEmpty() || zzf.size() > 2) {
+                    throw new IllegalArgumentException("bad parameter");
+                }
+                emptyMap.put(zza((String) zzf.get(0), str), zzf.size() == 2 ? zza((String) zzf.get(1), str) : null);
+            }
+        }
+        return emptyMap;
+    }
+
+    private static String zza(String str, String str2) {
+        if (str2 == null) {
+            str2 = "ISO-8859-1";
+        }
+        try {
+            return URLDecoder.decode(str, str2);
+        } catch (UnsupportedEncodingException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/common/util/IOUtils.java

@@ -0,0 +1,121 @@
+package com.google.android.gms.common.util;
+
+import android.os.ParcelFileDescriptor;
+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.ResultIgnorabilityUnspecified;
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+@ShowFirstParty
+@KeepForSdk
+@Deprecated
+/* loaded from: classes2.dex */
+public final class IOUtils {
+    private IOUtils() {
+    }
+
+    @KeepForSdk
+    public static void closeQuietly(ParcelFileDescriptor parcelFileDescriptor) {
+        if (parcelFileDescriptor != null) {
+            try {
+                parcelFileDescriptor.close();
+            } catch (IOException unused) {
+            }
+        }
+    }
+
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    @Deprecated
+    public static long copyStream(@NonNull InputStream inputStream, @NonNull OutputStream outputStream) throws IOException {
+        return copyStream(inputStream, outputStream, false, 1024);
+    }
+
+    @KeepForSdk
+    public static boolean isGzipByteBuffer(@NonNull byte[] bArr) {
+        if (bArr.length > 1) {
+            if ((((bArr[1] & 255) << 8) | (bArr[0] & 255)) == 35615) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static byte[] readInputStreamFully(@NonNull InputStream inputStream) throws IOException {
+        return readInputStreamFully(inputStream, true);
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static byte[] toByteArray(@NonNull InputStream inputStream) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        Preconditions.checkNotNull(inputStream);
+        Preconditions.checkNotNull(byteArrayOutputStream);
+        byte[] bArr = new byte[4096];
+        while (true) {
+            int read = inputStream.read(bArr);
+            if (read == -1) {
+                return byteArrayOutputStream.toByteArray();
+            }
+            byteArrayOutputStream.write(bArr, 0, read);
+        }
+    }
+
+    @KeepForSdk
+    public static void closeQuietly(Closeable closeable) {
+        if (closeable != null) {
+            try {
+                closeable.close();
+            } catch (IOException unused) {
+            }
+        }
+    }
+
+    @ResultIgnorabilityUnspecified
+    @KeepForSdk
+    @Deprecated
+    public static long copyStream(@NonNull InputStream inputStream, @NonNull OutputStream outputStream, boolean z, int i) throws IOException {
+        byte[] bArr = new byte[i];
+        long j = 0;
+        while (true) {
+            try {
+                int read = inputStream.read(bArr, 0, i);
+                if (read == -1) {
+                    break;
+                }
+                j += read;
+                outputStream.write(bArr, 0, read);
+            } catch (Throwable th) {
+                if (z) {
+                    closeQuietly(inputStream);
+                    closeQuietly(outputStream);
+                }
+                throw th;
+            }
+        }
+        if (z) {
+            closeQuietly(inputStream);
+            closeQuietly(outputStream);
+        }
+        return j;
+    }
+
+    @NonNull
+    @KeepForSdk
+    @Deprecated
+    public static byte[] readInputStreamFully(@NonNull InputStream inputStream, boolean z) throws IOException {
+        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+        copyStream(inputStream, byteArrayOutputStream, z, 1024);
+        return byteArrayOutputStream.toByteArray();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/JsonUtils.java

@@ -0,0 +1,155 @@
+package com.google.android.gms.common.util;
+
+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.Preconditions;
+import java.util.Iterator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class JsonUtils {
+    private static final Pattern zza = Pattern.compile("\\\\.");
+    private static final Pattern zzb = Pattern.compile("[\\\\\"/\b\f\n\r\t]");
+
+    private JsonUtils() {
+    }
+
+    @KeepForSdk
+    public static boolean areJsonValuesEquivalent(@Nullable Object obj, @Nullable Object obj2) {
+        if (obj == null && obj2 == null) {
+            return true;
+        }
+        if (obj == null || obj2 == null) {
+            return false;
+        }
+        if ((obj instanceof JSONObject) && (obj2 instanceof JSONObject)) {
+            JSONObject jSONObject = (JSONObject) obj;
+            JSONObject jSONObject2 = (JSONObject) obj2;
+            if (jSONObject.length() != jSONObject2.length()) {
+                return false;
+            }
+            Iterator<String> keys = jSONObject.keys();
+            while (keys.hasNext()) {
+                String next = keys.next();
+                if (!jSONObject2.has(next)) {
+                    return false;
+                }
+                try {
+                    Preconditions.checkNotNull(next);
+                } catch (JSONException unused) {
+                }
+                if (!areJsonValuesEquivalent(jSONObject.get(next), jSONObject2.get(next))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (!(obj instanceof JSONArray) || !(obj2 instanceof JSONArray)) {
+            return obj.equals(obj2);
+        }
+        JSONArray jSONArray = (JSONArray) obj;
+        JSONArray jSONArray2 = (JSONArray) obj2;
+        if (jSONArray.length() != jSONArray2.length()) {
+            return false;
+        }
+        for (int i = 0; i < jSONArray.length(); i++) {
+            if (!areJsonValuesEquivalent(jSONArray.get(i), jSONArray2.get(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static String escapeString(@Nullable String str) {
+        if (TextUtils.isEmpty(str)) {
+            return str;
+        }
+        Matcher matcher = zzb.matcher(str);
+        StringBuffer stringBuffer = null;
+        while (matcher.find()) {
+            if (stringBuffer == null) {
+                stringBuffer = new StringBuffer();
+            }
+            char charAt = matcher.group().charAt(0);
+            if (charAt == '\f') {
+                matcher.appendReplacement(stringBuffer, "\\\\f");
+            } else if (charAt == '\r') {
+                matcher.appendReplacement(stringBuffer, "\\\\r");
+            } else if (charAt == '\"') {
+                matcher.appendReplacement(stringBuffer, "\\\\\\\"");
+            } else if (charAt == '/') {
+                matcher.appendReplacement(stringBuffer, "\\\\/");
+            } else if (charAt != '\\') {
+                switch (charAt) {
+                    case '\b':
+                        matcher.appendReplacement(stringBuffer, "\\\\b");
+                        break;
+                    case '\t':
+                        matcher.appendReplacement(stringBuffer, "\\\\t");
+                        break;
+                    case '\n':
+                        matcher.appendReplacement(stringBuffer, "\\\\n");
+                        break;
+                }
+            } else {
+                matcher.appendReplacement(stringBuffer, "\\\\\\\\");
+            }
+        }
+        if (stringBuffer == null) {
+            return str;
+        }
+        matcher.appendTail(stringBuffer);
+        return stringBuffer.toString();
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String unescapeString(@NonNull String str) {
+        if (TextUtils.isEmpty(str)) {
+            return str;
+        }
+        String zza2 = zzc.zza(str);
+        Matcher matcher = zza.matcher(zza2);
+        StringBuffer stringBuffer = null;
+        while (matcher.find()) {
+            if (stringBuffer == null) {
+                stringBuffer = new StringBuffer();
+            }
+            char charAt = matcher.group().charAt(1);
+            if (charAt == '\"') {
+                matcher.appendReplacement(stringBuffer, "\"");
+            } else if (charAt == '/') {
+                matcher.appendReplacement(stringBuffer, "/");
+            } else if (charAt == '\\') {
+                matcher.appendReplacement(stringBuffer, "\\\\");
+            } else if (charAt == 'b') {
+                matcher.appendReplacement(stringBuffer, "\b");
+            } else if (charAt == 'f') {
+                matcher.appendReplacement(stringBuffer, "\f");
+            } else if (charAt == 'n') {
+                matcher.appendReplacement(stringBuffer, "\n");
+            } else if (charAt == 'r') {
+                matcher.appendReplacement(stringBuffer, "\r");
+            } else {
+                if (charAt != 't') {
+                    throw new IllegalStateException("Found an escaped character that should never be.");
+                }
+                matcher.appendReplacement(stringBuffer, "\t");
+            }
+        }
+        if (stringBuffer == null) {
+            return zza2;
+        }
+        matcher.appendTail(stringBuffer);
+        return stringBuffer.toString();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/MapUtils.java

@@ -0,0 +1,33 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import java.util.HashMap;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class MapUtils {
+    @KeepForSdk
+    public static void writeStringMapToJson(@NonNull StringBuilder sb, @NonNull HashMap<String, String> hashMap) {
+        sb.append("{");
+        boolean z = true;
+        for (String str : hashMap.keySet()) {
+            if (!z) {
+                sb.append(",");
+            }
+            String str2 = hashMap.get(str);
+            sb.append("\"");
+            sb.append(str);
+            sb.append("\":");
+            if (str2 == null) {
+                sb.append("null");
+            } else {
+                sb.append("\"");
+                sb.append(str2);
+                sb.append("\"");
+            }
+            z = false;
+        }
+        sb.append("}");
+    }
+}

decompiled/sources/com/google/android/gms/common/util/MurmurHash3.java

@@ -0,0 +1,45 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import androidx.collection.ScatterMapKt;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class MurmurHash3 {
+    private MurmurHash3() {
+    }
+
+    @KeepForSdk
+    public static int murmurhash3_x86_32(@NonNull byte[] bArr, int i, int i2, int i3) {
+        int i4;
+        int i5 = i;
+        while (true) {
+            i4 = (i2 & (-4)) + i;
+            if (i5 >= i4) {
+                break;
+            }
+            int i6 = ((bArr[i5] & 255) | ((bArr[i5 + 1] & 255) << 8) | ((bArr[i5 + 2] & 255) << 16) | (bArr[i5 + 3] << 24)) * ScatterMapKt.MurmurHashC1;
+            int i7 = i3 ^ (((i6 >>> 17) | (i6 << 15)) * 461845907);
+            i3 = (((i7 >>> 19) | (i7 << 13)) * 5) - 430675100;
+            i5 += 4;
+        }
+        int i8 = i2 & 3;
+        if (i8 != 1) {
+            if (i8 != 2) {
+                r0 = i8 == 3 ? (bArr[i4 + 2] & 255) << 16 : 0;
+                int i9 = i3 ^ i2;
+                int i10 = (i9 ^ (i9 >>> 16)) * (-2048144789);
+                int i11 = (i10 ^ (i10 >>> 13)) * (-1028477387);
+                return i11 ^ (i11 >>> 16);
+            }
+            r0 |= (bArr[i4 + 1] & 255) << 8;
+        }
+        int i12 = ((bArr[i4] & 255) | r0) * ScatterMapKt.MurmurHashC1;
+        i3 ^= ((i12 >>> 17) | (i12 << 15)) * 461845907;
+        int i92 = i3 ^ i2;
+        int i102 = (i92 ^ (i92 >>> 16)) * (-2048144789);
+        int i112 = (i102 ^ (i102 >>> 13)) * (-1028477387);
+        return i112 ^ (i112 >>> 16);
+    }
+}

decompiled/sources/com/google/android/gms/common/util/NumberUtils.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common.util;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class NumberUtils {
+    private NumberUtils() {
+    }
+}

decompiled/sources/com/google/android/gms/common/util/PlatformVersion.java

@@ -0,0 +1,151 @@
+package com.google.android.gms.common.util;
+
+import android.os.Build;
+import androidx.annotation.ChecksSdkIntAtLeast;
+import androidx.core.os.BuildCompat;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class PlatformVersion {
+    private PlatformVersion() {
+    }
+
+    @ChecksSdkIntAtLeast(api = 11)
+    @KeepForSdk
+    public static boolean isAtLeastHoneycomb() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 12)
+    @KeepForSdk
+    public static boolean isAtLeastHoneycombMR1() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 14)
+    @KeepForSdk
+    public static boolean isAtLeastIceCreamSandwich() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 15)
+    @KeepForSdk
+    public static boolean isAtLeastIceCreamSandwichMR1() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 16)
+    @KeepForSdk
+    public static boolean isAtLeastJellyBean() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 17)
+    @KeepForSdk
+    public static boolean isAtLeastJellyBeanMR1() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 18)
+    @KeepForSdk
+    public static boolean isAtLeastJellyBeanMR2() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 19)
+    @KeepForSdk
+    public static boolean isAtLeastKitKat() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 20)
+    @KeepForSdk
+    public static boolean isAtLeastKitKatWatch() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 21)
+    @KeepForSdk
+    public static boolean isAtLeastLollipop() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 22)
+    @KeepForSdk
+    public static boolean isAtLeastLollipopMR1() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 23)
+    @KeepForSdk
+    public static boolean isAtLeastM() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 24)
+    @KeepForSdk
+    public static boolean isAtLeastN() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 26)
+    @KeepForSdk
+    public static boolean isAtLeastO() {
+        return true;
+    }
+
+    @ChecksSdkIntAtLeast(api = 28)
+    @KeepForSdk
+    public static boolean isAtLeastP() {
+        return Build.VERSION.SDK_INT >= 28;
+    }
+
+    @ChecksSdkIntAtLeast(api = 29)
+    @KeepForSdk
+    public static boolean isAtLeastQ() {
+        return Build.VERSION.SDK_INT >= 29;
+    }
+
+    @ChecksSdkIntAtLeast(api = 30)
+    @KeepForSdk
+    public static boolean isAtLeastR() {
+        return Build.VERSION.SDK_INT >= 30;
+    }
+
+    @ChecksSdkIntAtLeast(api = 31)
+    @KeepForSdk
+    public static boolean isAtLeastS() {
+        return Build.VERSION.SDK_INT >= 31;
+    }
+
+    @ChecksSdkIntAtLeast(api = 32)
+    @KeepForSdk
+    public static boolean isAtLeastSv2() {
+        return Build.VERSION.SDK_INT >= 32;
+    }
+
+    @ChecksSdkIntAtLeast(api = 33)
+    @KeepForSdk
+    public static boolean isAtLeastT() {
+        return Build.VERSION.SDK_INT >= 33;
+    }
+
+    @ChecksSdkIntAtLeast(api = 33, codename = "UpsideDownCake")
+    @KeepForSdk
+    public static boolean isAtLeastU() {
+        if (isAtLeastT()) {
+            return BuildCompat.isAtLeastU();
+        }
+        return false;
+    }
+
+    @ChecksSdkIntAtLeast(api = 34, codename = "VanillaIceCream")
+    @KeepForSdk
+    public static boolean isAtLeastV() {
+        if (isAtLeastU()) {
+            return BuildCompat.isAtLeastV();
+        }
+        return false;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/Predicate.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public interface Predicate<T> {
+    @KeepForSdk
+    boolean apply(@NonNull T t);
+}

decompiled/sources/com/google/android/gms/common/util/ProcessUtils$$ExternalSyntheticApiModelOutline0.java

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

decompiled/sources/com/google/android/gms/common/util/ProcessUtils.java

@@ -0,0 +1,74 @@
+package com.google.android.gms.common.util;
+
+import android.app.Application;
+import android.os.Build;
+import android.os.Process;
+import android.os.StrictMode;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class ProcessUtils {
+    private static String zza;
+    private static int zzb;
+
+    private ProcessUtils() {
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static String getMyProcessName() {
+        BufferedReader bufferedReader;
+        String processName;
+        if (zza == null) {
+            if (Build.VERSION.SDK_INT >= 28) {
+                processName = Application.getProcessName();
+                zza = processName;
+            } else {
+                int i = zzb;
+                if (i == 0) {
+                    i = Process.myPid();
+                    zzb = i;
+                }
+                String str = null;
+                str = null;
+                str = null;
+                BufferedReader bufferedReader2 = null;
+                if (i > 0) {
+                    try {
+                        String str2 = "/proc/" + i + "/cmdline";
+                        StrictMode.ThreadPolicy allowThreadDiskReads = StrictMode.allowThreadDiskReads();
+                        try {
+                            bufferedReader = new BufferedReader(new FileReader(str2));
+                            try {
+                                String readLine = bufferedReader.readLine();
+                                Preconditions.checkNotNull(readLine);
+                                str = readLine.trim();
+                            } catch (IOException unused) {
+                            } catch (Throwable th) {
+                                th = th;
+                                bufferedReader2 = bufferedReader;
+                                IOUtils.closeQuietly(bufferedReader2);
+                                throw th;
+                            }
+                        } finally {
+                            StrictMode.setThreadPolicy(allowThreadDiskReads);
+                        }
+                    } catch (IOException unused2) {
+                        bufferedReader = null;
+                    } catch (Throwable th2) {
+                        th = th2;
+                    }
+                    IOUtils.closeQuietly(bufferedReader);
+                }
+                zza = str;
+            }
+        }
+        return zza;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/RetainForClient.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.common.util;
+
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public @interface RetainForClient {
+}

decompiled/sources/com/google/android/gms/common/util/ScopeUtil.java

@@ -0,0 +1,27 @@
+package com.google.android.gms.common.util;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.api.Scope;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.Set;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class ScopeUtil {
+    private ScopeUtil() {
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String[] toScopeString(@NonNull Set<Scope> set) {
+        Preconditions.checkNotNull(set, "scopes can't be null.");
+        Scope[] scopeArr = (Scope[]) set.toArray(new Scope[set.size()]);
+        Preconditions.checkNotNull(scopeArr, "scopes can't be null.");
+        String[] strArr = new String[scopeArr.length];
+        for (int i = 0; i < scopeArr.length; i++) {
+            strArr[i] = scopeArr[i].getScopeUri();
+        }
+        return strArr;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/SharedPreferencesUtils.java

@@ -0,0 +1,19 @@
+package com.google.android.gms.common.util;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class SharedPreferencesUtils {
+    private SharedPreferencesUtils() {
+    }
+
+    @KeepForSdk
+    @Deprecated
+    public static void publishWorldReadableSharedPreferences(@NonNull Context context, @NonNull SharedPreferences.Editor editor, @NonNull String str) {
+        throw new IllegalStateException("world-readable shared preferences should only be used by apk");
+    }
+}

decompiled/sources/com/google/android/gms/common/util/Strings.java

@@ -0,0 +1,29 @@
+package com.google.android.gms.common.util;
+
+import android.text.TextUtils;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import java.util.regex.Pattern;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class Strings {
+    private static final Pattern zza = Pattern.compile("\\$\\{(.*?)\\}");
+
+    private Strings() {
+    }
+
+    @Nullable
+    @KeepForSdk
+    public static String emptyToNull(@Nullable String str) {
+        if (TextUtils.isEmpty(str)) {
+            return null;
+        }
+        return str;
+    }
+
+    @KeepForSdk
+    public static boolean isEmptyOrWhitespace(@Nullable String str) {
+        return str == null || str.trim().isEmpty();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/UidVerifier.java

@@ -0,0 +1,36 @@
+package com.google.android.gms.common.util;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.GoogleSignatureVerifier;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.wrappers.Wrappers;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public final class UidVerifier {
+    private UidVerifier() {
+    }
+
+    @KeepForSdk
+    public static boolean isGooglePlayServicesUid(@NonNull Context context, int i) {
+        if (!uidHasPackageName(context, i, "com.google.android.gms")) {
+            return false;
+        }
+        try {
+            return GoogleSignatureVerifier.getInstance(context).isGooglePublicSignedPackage(context.getPackageManager().getPackageInfo("com.google.android.gms", 64));
+        } catch (PackageManager.NameNotFoundException unused) {
+            Log.isLoggable("UidVerifier", 3);
+            return false;
+        }
+    }
+
+    @KeepForSdk
+    @TargetApi(19)
+    public static boolean uidHasPackageName(@NonNull Context context, int i, @NonNull String str) {
+        return Wrappers.packageManager(context).zza(i, str);
+    }
+}

decompiled/sources/com/google/android/gms/common/util/WorkSourceUtil.java

@@ -0,0 +1,343 @@
+package com.google.android.gms.common.util;
+
+import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Process;
+import android.os.WorkSource;
+import android.util.Log;
+import androidx.annotation.GuardedBy;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.google.android.gms.common.wrappers.Wrappers;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class WorkSourceUtil {
+    private static final int zza = Process.myUid();
+    private static final Method zzb;
+    private static final Method zzc;
+    private static final Method zzd;
+    private static final Method zze;
+    private static final Method zzf;
+    private static final Method zzg;
+    private static final Method zzh;
+    private static final Method zzi;
+
+    @GuardedBy("WorkSourceUtil.class")
+    private static Boolean zzj;
+
+    /* JADX WARN: Can't wrap try/catch for region: R(26:0|1|(2:2|3)|4|(22:54|55|7|8|9|10|11|12|13|(13:46|47|16|(10:41|42|19|(7:36|37|22|(6:28|29|30|31|25|26)|24|25|26)|21|22|(0)|24|25|26)|18|19|(0)|21|22|(0)|24|25|26)|15|16|(0)|18|19|(0)|21|22|(0)|24|25|26)|6|7|8|9|10|11|12|13|(0)|15|16|(0)|18|19|(0)|21|22|(0)|24|25|26) */
+    /* JADX WARN: Code restructure failed: missing block: B:51:0x004d, code lost:
+    
+        r0 = null;
+     */
+    /* JADX WARN: Code restructure failed: missing block: B:53:0x003d, code lost:
+    
+        r0 = null;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x00aa A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:36:0x0086 A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:41:0x006e A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x0056 A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    static {
+        /*
+            java.lang.String r0 = "add"
+            java.lang.Class<android.os.WorkSource> r1 = android.os.WorkSource.class
+            int r2 = android.os.Process.myUid()
+            com.google.android.gms.common.util.WorkSourceUtil.zza = r2
+            r2 = 1
+            r3 = 0
+            r4 = 0
+            java.lang.Class[] r5 = new java.lang.Class[r2]     // Catch: java.lang.Exception -> L18
+            java.lang.Class r6 = java.lang.Integer.TYPE     // Catch: java.lang.Exception -> L18
+            r5[r3] = r6     // Catch: java.lang.Exception -> L18
+            java.lang.reflect.Method r5 = r1.getMethod(r0, r5)     // Catch: java.lang.Exception -> L18
+            goto L19
+        L18:
+            r5 = r4
+        L19:
+            com.google.android.gms.common.util.WorkSourceUtil.zzb = r5
+            boolean r5 = com.google.android.gms.common.util.PlatformVersion.isAtLeastJellyBeanMR2()
+            java.lang.Class<java.lang.String> r6 = java.lang.String.class
+            r7 = 2
+            if (r5 == 0) goto L31
+            java.lang.Class[] r5 = new java.lang.Class[r7]     // Catch: java.lang.Exception -> L31
+            java.lang.Class r8 = java.lang.Integer.TYPE     // Catch: java.lang.Exception -> L31
+            r5[r3] = r8     // Catch: java.lang.Exception -> L31
+            r5[r2] = r6     // Catch: java.lang.Exception -> L31
+            java.lang.reflect.Method r0 = r1.getMethod(r0, r5)     // Catch: java.lang.Exception -> L31
+            goto L32
+        L31:
+            r0 = r4
+        L32:
+            com.google.android.gms.common.util.WorkSourceUtil.zzc = r0
+            java.lang.String r0 = "size"
+            java.lang.Class[] r5 = new java.lang.Class[r3]     // Catch: java.lang.Exception -> L3d
+            java.lang.reflect.Method r0 = r1.getMethod(r0, r5)     // Catch: java.lang.Exception -> L3d
+            goto L3e
+        L3d:
+            r0 = r4
+        L3e:
+            com.google.android.gms.common.util.WorkSourceUtil.zzd = r0
+            java.lang.String r0 = "get"
+            java.lang.Class[] r5 = new java.lang.Class[r2]     // Catch: java.lang.Exception -> L4d
+            java.lang.Class r8 = java.lang.Integer.TYPE     // Catch: java.lang.Exception -> L4d
+            r5[r3] = r8     // Catch: java.lang.Exception -> L4d
+            java.lang.reflect.Method r0 = r1.getMethod(r0, r5)     // Catch: java.lang.Exception -> L4d
+            goto L4e
+        L4d:
+            r0 = r4
+        L4e:
+            com.google.android.gms.common.util.WorkSourceUtil.zze = r0
+            boolean r0 = com.google.android.gms.common.util.PlatformVersion.isAtLeastJellyBeanMR2()
+            if (r0 == 0) goto L63
+            java.lang.String r0 = "getName"
+            java.lang.Class[] r5 = new java.lang.Class[r2]     // Catch: java.lang.Exception -> L63
+            java.lang.Class r8 = java.lang.Integer.TYPE     // Catch: java.lang.Exception -> L63
+            r5[r3] = r8     // Catch: java.lang.Exception -> L63
+            java.lang.reflect.Method r0 = r1.getMethod(r0, r5)     // Catch: java.lang.Exception -> L63
+            goto L64
+        L63:
+            r0 = r4
+        L64:
+            com.google.android.gms.common.util.WorkSourceUtil.zzf = r0
+            boolean r0 = com.google.android.gms.common.util.PlatformVersion.isAtLeastP()
+            java.lang.String r5 = "WorkSourceUtil"
+            if (r0 == 0) goto L7d
+            java.lang.String r0 = "createWorkChain"
+            java.lang.Class[] r8 = new java.lang.Class[r3]     // Catch: java.lang.Exception -> L77
+            java.lang.reflect.Method r0 = r1.getMethod(r0, r8)     // Catch: java.lang.Exception -> L77
+            goto L7e
+        L77:
+            r0 = move-exception
+            java.lang.String r8 = "Missing WorkChain API createWorkChain"
+            android.util.Log.w(r5, r8, r0)
+        L7d:
+            r0 = r4
+        L7e:
+            com.google.android.gms.common.util.WorkSourceUtil.zzg = r0
+            boolean r0 = com.google.android.gms.common.util.PlatformVersion.isAtLeastP()
+            if (r0 == 0) goto La1
+            java.lang.String r0 = "android.os.WorkSource$WorkChain"
+            java.lang.Class r0 = java.lang.Class.forName(r0)     // Catch: java.lang.Exception -> L9b
+            java.lang.String r8 = "addNode"
+            java.lang.Class[] r7 = new java.lang.Class[r7]     // Catch: java.lang.Exception -> L9b
+            java.lang.Class r9 = java.lang.Integer.TYPE     // Catch: java.lang.Exception -> L9b
+            r7[r3] = r9     // Catch: java.lang.Exception -> L9b
+            r7[r2] = r6     // Catch: java.lang.Exception -> L9b
+            java.lang.reflect.Method r0 = r0.getMethod(r8, r7)     // Catch: java.lang.Exception -> L9b
+            goto La2
+        L9b:
+            r0 = move-exception
+            java.lang.String r6 = "Missing WorkChain class"
+            android.util.Log.w(r5, r6, r0)
+        La1:
+            r0 = r4
+        La2:
+            com.google.android.gms.common.util.WorkSourceUtil.zzh = r0
+            boolean r0 = com.google.android.gms.common.util.PlatformVersion.isAtLeastP()
+            if (r0 == 0) goto Lb6
+            java.lang.String r0 = "isEmpty"
+            java.lang.Class[] r3 = new java.lang.Class[r3]     // Catch: java.lang.Exception -> Lb6
+            java.lang.reflect.Method r0 = r1.getMethod(r0, r3)     // Catch: java.lang.Exception -> Lb6
+            r0.setAccessible(r2)     // Catch: java.lang.Exception -> Lb7
+            goto Lb7
+        Lb6:
+            r0 = r4
+        Lb7:
+            com.google.android.gms.common.util.WorkSourceUtil.zzi = r0
+            com.google.android.gms.common.util.WorkSourceUtil.zzj = r4
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.google.android.gms.common.util.WorkSourceUtil.<clinit>():void");
+    }
+
+    private WorkSourceUtil() {
+    }
+
+    @KeepForSdk
+    public static void add(@NonNull WorkSource workSource, int i, @NonNull String str) {
+        Method method = zzc;
+        if (method != null) {
+            if (str == null) {
+                str = "";
+            }
+            try {
+                method.invoke(workSource, Integer.valueOf(i), str);
+                return;
+            } catch (Exception e) {
+                Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", e);
+                return;
+            }
+        }
+        Method method2 = zzb;
+        if (method2 != null) {
+            try {
+                method2.invoke(workSource, Integer.valueOf(i));
+            } catch (Exception e2) {
+                Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", e2);
+            }
+        }
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static WorkSource fromPackage(@NonNull Context context, @NonNull String str) {
+        if (context != null && context.getPackageManager() != null && str != null) {
+            try {
+                ApplicationInfo applicationInfo = Wrappers.packageManager(context).getApplicationInfo(str, 0);
+                if (applicationInfo == null) {
+                    Log.e("WorkSourceUtil", "Could not get applicationInfo from package: ".concat(str));
+                    return null;
+                }
+                int i = applicationInfo.uid;
+                WorkSource workSource = new WorkSource();
+                add(workSource, i, str);
+                return workSource;
+            } catch (PackageManager.NameNotFoundException unused) {
+                Log.e("WorkSourceUtil", "Could not find package: ".concat(str));
+            }
+        }
+        return null;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static WorkSource fromPackageAndModuleExperimentalPi(@NonNull Context context, @NonNull String str, @NonNull String str2) {
+        Method method;
+        if (context == null || context.getPackageManager() == null || str2 == null || str == null) {
+            Log.w("WorkSourceUtil", "Unexpected null arguments");
+            return null;
+        }
+        int i = -1;
+        try {
+            ApplicationInfo applicationInfo = Wrappers.packageManager(context).getApplicationInfo(str, 0);
+            if (applicationInfo == null) {
+                Log.e("WorkSourceUtil", "Could not get applicationInfo from package: ".concat(str));
+            } else {
+                i = applicationInfo.uid;
+            }
+        } catch (PackageManager.NameNotFoundException unused) {
+            Log.e("WorkSourceUtil", "Could not find package: ".concat(str));
+        }
+        if (i < 0) {
+            return null;
+        }
+        WorkSource workSource = new WorkSource();
+        Method method2 = zzg;
+        if (method2 == null || (method = zzh) == null) {
+            add(workSource, i, str);
+        } else {
+            try {
+                Object invoke = method2.invoke(workSource, new Object[0]);
+                int i2 = zza;
+                if (i != i2) {
+                    method.invoke(invoke, Integer.valueOf(i), str);
+                }
+                method.invoke(invoke, Integer.valueOf(i2), str2);
+            } catch (Exception e) {
+                Log.w("WorkSourceUtil", "Unable to assign chained blame through WorkSource", e);
+            }
+        }
+        return workSource;
+    }
+
+    @KeepForSdk
+    public static int get(@NonNull WorkSource workSource, int i) {
+        Method method = zze;
+        if (method != null) {
+            try {
+                Object invoke = method.invoke(workSource, Integer.valueOf(i));
+                Preconditions.checkNotNull(invoke);
+                return ((Integer) invoke).intValue();
+            } catch (Exception e) {
+                Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", e);
+            }
+        }
+        return 0;
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static String getName(@NonNull WorkSource workSource, int i) {
+        Method method = zzf;
+        if (method == null) {
+            return null;
+        }
+        try {
+            return (String) method.invoke(workSource, Integer.valueOf(i));
+        } catch (Exception e) {
+            Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", e);
+            return null;
+        }
+    }
+
+    @NonNull
+    @KeepForSdk
+    public static List<String> getNames(@NonNull WorkSource workSource) {
+        ArrayList arrayList = new ArrayList();
+        int size = workSource == null ? 0 : size(workSource);
+        if (size != 0) {
+            for (int i = 0; i < size; i++) {
+                String name = getName(workSource, i);
+                if (!Strings.isEmptyOrWhitespace(name)) {
+                    Preconditions.checkNotNull(name);
+                    arrayList.add(name);
+                }
+            }
+        }
+        return arrayList;
+    }
+
+    @KeepForSdk
+    public static synchronized boolean hasWorkSourcePermission(@NonNull Context context) {
+        synchronized (WorkSourceUtil.class) {
+            Boolean bool = zzj;
+            if (bool != null) {
+                return bool.booleanValue();
+            }
+            if (context == null) {
+                return false;
+            }
+            Boolean valueOf = Boolean.valueOf(ContextCompat.checkSelfPermission(context, "android.permission.UPDATE_DEVICE_STATS") == 0);
+            zzj = valueOf;
+            return valueOf.booleanValue();
+        }
+    }
+
+    @KeepForSdk
+    public static boolean isEmpty(@NonNull WorkSource workSource) {
+        Method method = zzi;
+        if (method != null) {
+            try {
+                Object invoke = method.invoke(workSource, new Object[0]);
+                Preconditions.checkNotNull(invoke);
+                return ((Boolean) invoke).booleanValue();
+            } catch (Exception e) {
+                Log.e("WorkSourceUtil", "Unable to check WorkSource emptiness", e);
+            }
+        }
+        return size(workSource) == 0;
+    }
+
+    @KeepForSdk
+    public static int size(@NonNull WorkSource workSource) {
+        Method method = zzd;
+        if (method != null) {
+            try {
+                Object invoke = method.invoke(workSource, new Object[0]);
+                Preconditions.checkNotNull(invoke);
+                return ((Integer) invoke).intValue();
+            } catch (Exception e) {
+                Log.wtf("WorkSourceUtil", "Unable to assign blame through WorkSource", e);
+            }
+        }
+        return 0;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/concurrent/HandlerExecutor.java

@@ -0,0 +1,24 @@
+package com.google.android.gms.common.util.concurrent;
+
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.internal.common.zzi;
+import java.util.concurrent.Executor;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class HandlerExecutor implements Executor {
+    private final Handler zza;
+
+    @KeepForSdk
+    public HandlerExecutor(@NonNull Looper looper) {
+        this.zza = new zzi(looper);
+    }
+
+    @Override // java.util.concurrent.Executor
+    public final void execute(@NonNull Runnable runnable) {
+        this.zza.post(runnable);
+    }
+}

decompiled/sources/com/google/android/gms/common/util/concurrent/NamedThreadFactory.java

@@ -0,0 +1,28 @@
+package com.google.android.gms.common.util.concurrent;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class NamedThreadFactory implements ThreadFactory {
+    private final String zza;
+    private final ThreadFactory zzb = Executors.defaultThreadFactory();
+
+    @KeepForSdk
+    public NamedThreadFactory(@NonNull String str) {
+        Preconditions.checkNotNull(str, "Name must not be null");
+        this.zza = str;
+    }
+
+    @Override // java.util.concurrent.ThreadFactory
+    @NonNull
+    public final Thread newThread(@NonNull Runnable runnable) {
+        Thread newThread = this.zzb.newThread(new zza(runnable, 0));
+        newThread.setName(this.zza);
+        return newThread;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/concurrent/NumberedThreadFactory.java

@@ -0,0 +1,31 @@
+package com.google.android.gms.common.util.concurrent;
+
+import androidx.annotation.NonNull;
+import com.google.android.gms.common.annotation.KeepForSdk;
+import com.google.android.gms.common.internal.Preconditions;
+import com.ironsource.v8;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@KeepForSdk
+/* loaded from: classes2.dex */
+public class NumberedThreadFactory implements ThreadFactory {
+    private final String zza;
+    private final AtomicInteger zzb = new AtomicInteger();
+    private final ThreadFactory zzc = Executors.defaultThreadFactory();
+
+    @KeepForSdk
+    public NumberedThreadFactory(@NonNull String str) {
+        Preconditions.checkNotNull(str, "Name must not be null");
+        this.zza = str;
+    }
+
+    @Override // java.util.concurrent.ThreadFactory
+    @NonNull
+    public final Thread newThread(@NonNull Runnable runnable) {
+        Thread newThread = this.zzc.newThread(new zza(runnable, 0));
+        newThread.setName(this.zza + v8.i.d + this.zzb.getAndIncrement() + v8.i.e);
+        return newThread;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/concurrent/zza.java

@@ -0,0 +1,18 @@
+package com.google.android.gms.common.util.concurrent;
+
+import android.os.Process;
+
+/* loaded from: classes2.dex */
+final class zza implements Runnable {
+    private final Runnable zza;
+
+    public zza(Runnable runnable, int i) {
+        this.zza = runnable;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Process.setThreadPriority(0);
+        this.zza.run();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/zza.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.common.util;
+
+/* loaded from: classes2.dex */
+public final class zza {
+    public static int zza(int i) {
+        if (i == -1) {
+            return -1;
+        }
+        return i / 1000;
+    }
+}

decompiled/sources/com/google/android/gms/common/util/zzb.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.common.util;
+
+import android.os.Looper;
+
+/* loaded from: classes2.dex */
+public final class zzb {
+    public static boolean zza() {
+        return Looper.getMainLooper() == Looper.myLooper();
+    }
+}

decompiled/sources/com/google/android/gms/common/util/zzc.java

@@ -0,0 +1,46 @@
+package com.google.android.gms.common.util;
+
+import android.text.TextUtils;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* loaded from: classes2.dex */
+final class zzc {
+    private static final Pattern zza = Pattern.compile("\\\\u[0-9a-fA-F]{4}");
+
+    public static String zza(String str) {
+        if (TextUtils.isEmpty(str)) {
+            return str;
+        }
+        Matcher matcher = zza.matcher(str);
+        StringBuilder sb = null;
+        int i = 0;
+        while (matcher.find()) {
+            if (sb == null) {
+                sb = new StringBuilder();
+            }
+            int start = matcher.start();
+            int i2 = start;
+            while (i2 >= 0 && str.charAt(i2) == '\\') {
+                i2--;
+            }
+            if ((start - i2) % 2 != 0) {
+                int parseInt = Integer.parseInt(matcher.group().substring(2), 16);
+                sb.append((CharSequence) str, i, matcher.start());
+                if (parseInt == 92) {
+                    sb.append("\\\\");
+                } else {
+                    sb.append(Character.toChars(parseInt));
+                }
+                i = matcher.end();
+            }
+        }
+        if (sb == null) {
+            return str;
+        }
+        if (i < matcher.regionEnd()) {
+            sb.append((CharSequence) str, i, matcher.regionEnd());
+        }
+        return sb.toString();
+    }
+}