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/common/base/Absent.java

@@ -0,0 +1,37 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public final class Absent extends Optional {
+    public static final Absent INSTANCE = new Absent();
+    private static final long serialVersionUID = 0;
+
+    private Object readResolve() {
+        return INSTANCE;
+    }
+
+    public static Optional withType() {
+        return INSTANCE;
+    }
+
+    public boolean equals(Object obj) {
+        return obj == this;
+    }
+
+    public int hashCode() {
+        return 2040732332;
+    }
+
+    @Override // com.google.common.base.Optional
+    public boolean isPresent() {
+        return false;
+    }
+
+    public String toString() {
+        return "Optional.absent()";
+    }
+
+    @Override // com.google.common.base.Optional
+    public Object get() {
+        throw new IllegalStateException("Optional.get() cannot be called on an absent value");
+    }
+}

decompiled/sources/com/google/common/base/Ascii.java

@@ -0,0 +1,28 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public abstract class Ascii {
+    public static boolean isUpperCase(char c) {
+        return c >= 'A' && c <= 'Z';
+    }
+
+    public static String toLowerCase(String str) {
+        int length = str.length();
+        int i = 0;
+        while (i < length) {
+            if (isUpperCase(str.charAt(i))) {
+                char[] charArray = str.toCharArray();
+                while (i < length) {
+                    char c = charArray[i];
+                    if (isUpperCase(c)) {
+                        charArray[i] = (char) (c ^ ' ');
+                    }
+                    i++;
+                }
+                return String.valueOf(charArray);
+            }
+            i++;
+        }
+        return str;
+    }
+}

decompiled/sources/com/google/common/base/Charsets.java

@@ -0,0 +1,13 @@
+package com.google.common.base;
+
+import java.nio.charset.Charset;
+
+/* loaded from: classes3.dex */
+public abstract class Charsets {
+    public static final Charset US_ASCII = Charset.forName("US-ASCII");
+    public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
+    public static final Charset UTF_8 = Charset.forName("UTF-8");
+    public static final Charset UTF_16BE = Charset.forName("UTF-16BE");
+    public static final Charset UTF_16LE = Charset.forName("UTF-16LE");
+    public static final Charset UTF_16 = Charset.forName("UTF-16");
+}

decompiled/sources/com/google/common/base/ExtraObjectsMethodsForWeb.java

@@ -0,0 +1,5 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public abstract class ExtraObjectsMethodsForWeb {
+}

decompiled/sources/com/google/common/base/Function.java

@@ -0,0 +1,8 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public interface Function {
+    Object apply(Object obj);
+
+    boolean equals(Object obj);
+}

decompiled/sources/com/google/common/base/MoreObjects.java

@@ -0,0 +1,135 @@
+package com.google.common.base;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Map;
+
+/* loaded from: classes3.dex */
+public abstract class MoreObjects {
+    public static ToStringHelper toStringHelper(Object obj) {
+        return new ToStringHelper(obj.getClass().getSimpleName());
+    }
+
+    public static final class ToStringHelper {
+        public final String className;
+        public final ValueHolder holderHead;
+        public ValueHolder holderTail;
+        public boolean omitEmptyValues;
+        public boolean omitNullValues;
+
+        public ToStringHelper(String str) {
+            ValueHolder valueHolder = new ValueHolder();
+            this.holderHead = valueHolder;
+            this.holderTail = valueHolder;
+            this.omitNullValues = false;
+            this.omitEmptyValues = false;
+            this.className = (String) Preconditions.checkNotNull(str);
+        }
+
+        public ToStringHelper addValue(Object obj) {
+            return addHolder(obj);
+        }
+
+        public static boolean isEmpty(Object obj) {
+            if (obj instanceof CharSequence) {
+                return ((CharSequence) obj).length() == 0;
+            }
+            if (obj instanceof Collection) {
+                return ((Collection) obj).isEmpty();
+            }
+            if (obj instanceof Map) {
+                return ((Map) obj).isEmpty();
+            }
+            if (obj instanceof Optional) {
+                return !((Optional) obj).isPresent();
+            }
+            return obj.getClass().isArray() && Array.getLength(obj) == 0;
+        }
+
+        /* JADX WARN: Removed duplicated region for block: B:8:0x0033  */
+        /*
+            Code decompiled incorrectly, please refer to instructions dump.
+            To view partially-correct add '--show-bad-code' argument
+        */
+        public java.lang.String toString() {
+            /*
+                r7 = this;
+                boolean r0 = r7.omitNullValues
+                boolean r1 = r7.omitEmptyValues
+                java.lang.StringBuilder r2 = new java.lang.StringBuilder
+                r3 = 32
+                r2.<init>(r3)
+                java.lang.String r3 = r7.className
+                r2.append(r3)
+                r3 = 123(0x7b, float:1.72E-43)
+                r2.append(r3)
+                com.google.common.base.MoreObjects$ToStringHelper$ValueHolder r3 = r7.holderHead
+                com.google.common.base.MoreObjects$ToStringHelper$ValueHolder r3 = r3.next
+                java.lang.String r4 = ""
+            L1b:
+                if (r3 == 0) goto L61
+                java.lang.Object r5 = r3.value
+                if (r5 != 0) goto L24
+                if (r0 != 0) goto L5e
+                goto L2c
+            L24:
+                if (r1 == 0) goto L2c
+                boolean r6 = isEmpty(r5)
+                if (r6 != 0) goto L5e
+            L2c:
+                r2.append(r4)
+                java.lang.String r4 = r3.name
+                if (r4 == 0) goto L3b
+                r2.append(r4)
+                r4 = 61
+                r2.append(r4)
+            L3b:
+                if (r5 == 0) goto L59
+                java.lang.Class r4 = r5.getClass()
+                boolean r4 = r4.isArray()
+                if (r4 == 0) goto L59
+                java.lang.Object[] r4 = new java.lang.Object[]{r5}
+                java.lang.String r4 = java.util.Arrays.deepToString(r4)
+                int r5 = r4.length()
+                r6 = 1
+                int r5 = r5 - r6
+                r2.append(r4, r6, r5)
+                goto L5c
+            L59:
+                r2.append(r5)
+            L5c:
+                java.lang.String r4 = ", "
+            L5e:
+                com.google.common.base.MoreObjects$ToStringHelper$ValueHolder r3 = r3.next
+                goto L1b
+            L61:
+                r0 = 125(0x7d, float:1.75E-43)
+                r2.append(r0)
+                java.lang.String r0 = r2.toString()
+                return r0
+            */
+            throw new UnsupportedOperationException("Method not decompiled: com.google.common.base.MoreObjects.ToStringHelper.toString():java.lang.String");
+        }
+
+        public final ValueHolder addHolder() {
+            ValueHolder valueHolder = new ValueHolder();
+            this.holderTail.next = valueHolder;
+            this.holderTail = valueHolder;
+            return valueHolder;
+        }
+
+        public final ToStringHelper addHolder(Object obj) {
+            addHolder().value = obj;
+            return this;
+        }
+
+        public static class ValueHolder {
+            public String name;
+            public ValueHolder next;
+            public Object value;
+
+            public ValueHolder() {
+            }
+        }
+    }
+}

decompiled/sources/com/google/common/base/NullnessCasts.java

@@ -0,0 +1,8 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public abstract class NullnessCasts {
+    public static Object uncheckedCastNullableTToT(Object obj) {
+        return obj;
+    }
+}

decompiled/sources/com/google/common/base/Objects.java

@@ -0,0 +1,14 @@
+package com.google.common.base;
+
+import java.util.Arrays;
+
+/* loaded from: classes3.dex */
+public abstract class Objects extends ExtraObjectsMethodsForWeb {
+    public static boolean equal(Object obj, Object obj2) {
+        return obj == obj2 || (obj != null && obj.equals(obj2));
+    }
+
+    public static int hashCode(Object... objArr) {
+        return Arrays.hashCode(objArr);
+    }
+}

decompiled/sources/com/google/common/base/Optional.java

@@ -0,0 +1,20 @@
+package com.google.common.base;
+
+import java.io.Serializable;
+
+/* loaded from: classes3.dex */
+public abstract class Optional implements Serializable {
+    private static final long serialVersionUID = 0;
+
+    public abstract Object get();
+
+    public abstract boolean isPresent();
+
+    public static Optional absent() {
+        return Absent.withType();
+    }
+
+    public static Optional of(Object obj) {
+        return new Present(Preconditions.checkNotNull(obj));
+    }
+}

decompiled/sources/com/google/common/base/Preconditions.java

@@ -0,0 +1,110 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public abstract class Preconditions {
+    public static void checkArgument(boolean z) {
+        if (!z) {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public static void checkArgument(boolean z, Object obj) {
+        if (!z) {
+            throw new IllegalArgumentException(String.valueOf(obj));
+        }
+    }
+
+    public static void checkArgument(boolean z, String str, int i, int i2) {
+        if (!z) {
+            throw new IllegalArgumentException(Strings.lenientFormat(str, Integer.valueOf(i), Integer.valueOf(i2)));
+        }
+    }
+
+    public static void checkState(boolean z, Object obj) {
+        if (!z) {
+            throw new IllegalStateException(String.valueOf(obj));
+        }
+    }
+
+    public static void checkState(boolean z, String str, Object obj) {
+        if (!z) {
+            throw new IllegalStateException(Strings.lenientFormat(str, obj));
+        }
+    }
+
+    public static Object checkNotNull(Object obj) {
+        obj.getClass();
+        return obj;
+    }
+
+    public static Object checkNotNull(Object obj, Object obj2) {
+        if (obj != null) {
+            return obj;
+        }
+        throw new NullPointerException(String.valueOf(obj2));
+    }
+
+    public static int checkElementIndex(int i, int i2) {
+        return checkElementIndex(i, i2, "index");
+    }
+
+    public static int checkElementIndex(int i, int i2, String str) {
+        if (i < 0 || i >= i2) {
+            throw new IndexOutOfBoundsException(badElementIndex(i, i2, str));
+        }
+        return i;
+    }
+
+    public static String badElementIndex(int i, int i2, String str) {
+        if (i < 0) {
+            return Strings.lenientFormat("%s (%s) must not be negative", str, Integer.valueOf(i));
+        }
+        if (i2 < 0) {
+            StringBuilder sb = new StringBuilder(26);
+            sb.append("negative size: ");
+            sb.append(i2);
+            throw new IllegalArgumentException(sb.toString());
+        }
+        return Strings.lenientFormat("%s (%s) must be less than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
+    }
+
+    public static int checkPositionIndex(int i, int i2) {
+        return checkPositionIndex(i, i2, "index");
+    }
+
+    public static int checkPositionIndex(int i, int i2, String str) {
+        if (i < 0 || i > i2) {
+            throw new IndexOutOfBoundsException(badPositionIndex(i, i2, str));
+        }
+        return i;
+    }
+
+    public static String badPositionIndex(int i, int i2, String str) {
+        if (i < 0) {
+            return Strings.lenientFormat("%s (%s) must not be negative", str, Integer.valueOf(i));
+        }
+        if (i2 < 0) {
+            StringBuilder sb = new StringBuilder(26);
+            sb.append("negative size: ");
+            sb.append(i2);
+            throw new IllegalArgumentException(sb.toString());
+        }
+        return Strings.lenientFormat("%s (%s) must not be greater than size (%s)", str, Integer.valueOf(i), Integer.valueOf(i2));
+    }
+
+    public static void checkPositionIndexes(int i, int i2, int i3) {
+        if (i < 0 || i2 < i || i2 > i3) {
+            throw new IndexOutOfBoundsException(badPositionIndexes(i, i2, i3));
+        }
+    }
+
+    public static String badPositionIndexes(int i, int i2, int i3) {
+        if (i < 0 || i > i3) {
+            return badPositionIndex(i, i3, "start index");
+        }
+        if (i2 < 0 || i2 > i3) {
+            return badPositionIndex(i2, i3, "end index");
+        }
+        return Strings.lenientFormat("end index (%s) must not be less than start index (%s)", Integer.valueOf(i2), Integer.valueOf(i));
+    }
+}

decompiled/sources/com/google/common/base/Present.java

@@ -0,0 +1,41 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public final class Present extends Optional {
+    private static final long serialVersionUID = 0;
+    public final Object reference;
+
+    @Override // com.google.common.base.Optional
+    public Object get() {
+        return this.reference;
+    }
+
+    @Override // com.google.common.base.Optional
+    public boolean isPresent() {
+        return true;
+    }
+
+    public Present(Object obj) {
+        this.reference = obj;
+    }
+
+    public boolean equals(Object obj) {
+        if (obj instanceof Present) {
+            return this.reference.equals(((Present) obj).reference);
+        }
+        return false;
+    }
+
+    public int hashCode() {
+        return this.reference.hashCode() + 1502476572;
+    }
+
+    public String toString() {
+        String valueOf = String.valueOf(this.reference);
+        StringBuilder sb = new StringBuilder(valueOf.length() + 13);
+        sb.append("Optional.of(");
+        sb.append(valueOf);
+        sb.append(")");
+        return sb.toString();
+    }
+}

decompiled/sources/com/google/common/base/Strings.java

@@ -0,0 +1,68 @@
+package com.google.common.base;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/* loaded from: classes3.dex */
+public abstract class Strings {
+    public static String lenientFormat(String str, Object... objArr) {
+        int indexOf;
+        String valueOf = String.valueOf(str);
+        int i = 0;
+        if (objArr == null) {
+            objArr = new Object[]{"(Object[])null"};
+        } else {
+            for (int i2 = 0; i2 < objArr.length; i2++) {
+                objArr[i2] = lenientToString(objArr[i2]);
+            }
+        }
+        StringBuilder sb = new StringBuilder(valueOf.length() + (objArr.length * 16));
+        int i3 = 0;
+        while (i < objArr.length && (indexOf = valueOf.indexOf("%s", i3)) != -1) {
+            sb.append((CharSequence) valueOf, i3, indexOf);
+            sb.append(objArr[i]);
+            i3 = indexOf + 2;
+            i++;
+        }
+        sb.append((CharSequence) valueOf, i3, valueOf.length());
+        if (i < objArr.length) {
+            sb.append(" [");
+            sb.append(objArr[i]);
+            for (int i4 = i + 1; i4 < objArr.length; i4++) {
+                sb.append(", ");
+                sb.append(objArr[i4]);
+            }
+            sb.append(']');
+        }
+        return sb.toString();
+    }
+
+    public static String lenientToString(Object obj) {
+        if (obj == null) {
+            return "null";
+        }
+        try {
+            return obj.toString();
+        } catch (Exception e) {
+            String name = obj.getClass().getName();
+            String hexString = Integer.toHexString(System.identityHashCode(obj));
+            StringBuilder sb = new StringBuilder(name.length() + 1 + String.valueOf(hexString).length());
+            sb.append(name);
+            sb.append('@');
+            sb.append(hexString);
+            String sb2 = sb.toString();
+            Logger logger = Logger.getLogger("com.google.common.base.Strings");
+            Level level = Level.WARNING;
+            String valueOf = String.valueOf(sb2);
+            logger.log(level, valueOf.length() != 0 ? "Exception during lenientFormat for ".concat(valueOf) : new String("Exception during lenientFormat for "), (Throwable) e);
+            String name2 = e.getClass().getName();
+            StringBuilder sb3 = new StringBuilder(String.valueOf(sb2).length() + 9 + name2.length());
+            sb3.append("<");
+            sb3.append(sb2);
+            sb3.append(" threw ");
+            sb3.append(name2);
+            sb3.append(">");
+            return sb3.toString();
+        }
+    }
+}

decompiled/sources/com/google/common/base/Supplier.java

@@ -0,0 +1,6 @@
+package com.google.common.base;
+
+/* loaded from: classes3.dex */
+public interface Supplier {
+    Object get();
+}

decompiled/sources/com/google/common/base/Suppliers.java

@@ -0,0 +1,152 @@
+package com.google.common.base;
+
+import java.io.Serializable;
+
+/* loaded from: classes3.dex */
+public abstract class Suppliers {
+    public static Supplier memoize(Supplier supplier) {
+        if ((supplier instanceof NonSerializableMemoizingSupplier) || (supplier instanceof MemoizingSupplier)) {
+            return supplier;
+        }
+        if (supplier instanceof Serializable) {
+            return new MemoizingSupplier(supplier);
+        }
+        return new NonSerializableMemoizingSupplier(supplier);
+    }
+
+    public static class MemoizingSupplier implements Supplier, Serializable {
+        private static final long serialVersionUID = 0;
+        public final Supplier delegate;
+        public volatile transient boolean initialized;
+        public transient Object value;
+
+        public MemoizingSupplier(Supplier supplier) {
+            this.delegate = (Supplier) Preconditions.checkNotNull(supplier);
+        }
+
+        @Override // com.google.common.base.Supplier
+        public Object get() {
+            if (!this.initialized) {
+                synchronized (this) {
+                    try {
+                        if (!this.initialized) {
+                            Object obj = this.delegate.get();
+                            this.value = obj;
+                            this.initialized = true;
+                            return obj;
+                        }
+                    } finally {
+                    }
+                }
+            }
+            return NullnessCasts.uncheckedCastNullableTToT(this.value);
+        }
+
+        public String toString() {
+            Object obj;
+            if (this.initialized) {
+                String valueOf = String.valueOf(this.value);
+                StringBuilder sb = new StringBuilder(valueOf.length() + 25);
+                sb.append("<supplier that returned ");
+                sb.append(valueOf);
+                sb.append(">");
+                obj = sb.toString();
+            } else {
+                obj = this.delegate;
+            }
+            String valueOf2 = String.valueOf(obj);
+            StringBuilder sb2 = new StringBuilder(valueOf2.length() + 19);
+            sb2.append("Suppliers.memoize(");
+            sb2.append(valueOf2);
+            sb2.append(")");
+            return sb2.toString();
+        }
+    }
+
+    public static class NonSerializableMemoizingSupplier implements Supplier {
+        public volatile Supplier delegate;
+        public volatile boolean initialized;
+        public Object value;
+
+        public NonSerializableMemoizingSupplier(Supplier supplier) {
+            this.delegate = (Supplier) Preconditions.checkNotNull(supplier);
+        }
+
+        @Override // com.google.common.base.Supplier
+        public Object get() {
+            if (!this.initialized) {
+                synchronized (this) {
+                    try {
+                        if (!this.initialized) {
+                            Supplier supplier = this.delegate;
+                            java.util.Objects.requireNonNull(supplier);
+                            Object obj = supplier.get();
+                            this.value = obj;
+                            this.initialized = true;
+                            this.delegate = null;
+                            return obj;
+                        }
+                    } finally {
+                    }
+                }
+            }
+            return NullnessCasts.uncheckedCastNullableTToT(this.value);
+        }
+
+        public String toString() {
+            Object obj = this.delegate;
+            if (obj == null) {
+                String valueOf = String.valueOf(this.value);
+                StringBuilder sb = new StringBuilder(valueOf.length() + 25);
+                sb.append("<supplier that returned ");
+                sb.append(valueOf);
+                sb.append(">");
+                obj = sb.toString();
+            }
+            String valueOf2 = String.valueOf(obj);
+            StringBuilder sb2 = new StringBuilder(valueOf2.length() + 19);
+            sb2.append("Suppliers.memoize(");
+            sb2.append(valueOf2);
+            sb2.append(")");
+            return sb2.toString();
+        }
+    }
+
+    public static Supplier ofInstance(Object obj) {
+        return new SupplierOfInstance(obj);
+    }
+
+    public static class SupplierOfInstance implements Supplier, Serializable {
+        private static final long serialVersionUID = 0;
+        public final Object instance;
+
+        @Override // com.google.common.base.Supplier
+        public Object get() {
+            return this.instance;
+        }
+
+        public SupplierOfInstance(Object obj) {
+            this.instance = obj;
+        }
+
+        public boolean equals(Object obj) {
+            if (obj instanceof SupplierOfInstance) {
+                return Objects.equal(this.instance, ((SupplierOfInstance) obj).instance);
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return Objects.hashCode(this.instance);
+        }
+
+        public String toString() {
+            String valueOf = String.valueOf(this.instance);
+            StringBuilder sb = new StringBuilder(valueOf.length() + 22);
+            sb.append("Suppliers.ofInstance(");
+            sb.append(valueOf);
+            sb.append(")");
+            return sb.toString();
+        }
+    }
+}